L'égalité vient en trois

11

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.

code-golf  number  sequence 
— Urne de poulpe magique
source
Ahhh crappp, je n'ai pas remarqué la formule directe sur OEIS, je pensais que ce ne serait pas si simple. Eh bien, je ne suis pas +1 sur les ports directs de cette équation; P.
— Magic Octopus Urn
1
Au moins, la formule n'était pas parfaitement jouée: P
— fəˈnɛtɪk
Là encore, cela donne une chance aux reg-langs contre les eso-langs.
— Urne de poulpe magique du
Serait-il préférable que le titre soit "l'égalité vient en triplets"?
— Leaky Nun

Réponses:

11

Gelée , 9 6 octets

ṗ6ḅ-ċ0

Solution O (n 6 ) .

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.
— Dennis
source
Ha! Je dois aimer les réponses théoriques (ma base pour une réponse théorique est maintenant qu'elle fonctionne sur TIO pour les grandes valeurs de n , c'est probablement mauvais). J'espérais voir un O(n^6)bien: P.
— Urne de poulpe magique
9

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]&
— Kelly Lowder
source
2
Merci d'avoir posté de manière non-brute-force :). +1 pour toute réponse mathématique qui n'est pas une équation ou une réponse intégrée.
— Urne de poulpe magique
Selon cette réponse , vous pouvez remplacer 11/20par .55pour une économie de deux octets.
— Greg Martin
Vous n'avez pas non plus besoin de l'astérisque au premier trimestre.
— ngenisis
8

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.

— Ørjan Johansen
source
J'ai remarqué que, souvent, la réponse la plus courte est la moins impressionnante;). Ceci est une utilisation assez cool du pli que je n'aurais pas envisagé avant de voir cette réponse.
— Urne de poulpe magique du
6

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
— Luis Mendo
source
5

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.
— ETHproductions
source
Pouvez-vous expliquer cette méthode? Je suis actuellement en train d'apprendre Jelly, mais je ne suis pas encore assez bon pour soumettre de vraies réponses; Je me tourne toujours vers toi, Dennis et quelques autres pour de bons exemples.
— Urne de poulpe magique du
@carusocomputing Fin de l'explication. Faites-moi savoir si vous avez encore des questions :-)
— ETHproductions
Génial, je suis surtout confus sur l'optimisation des réponses de l'implémentation de force brute la plus basique que je ferais pour le code court fou que je vous vois publier; mais j'ai l'impression que chaque explication est un pas de plus merci!
— Urne de poulpe magique du
5

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.
+1 pour ne pas utiliser la formule directe: P.
— Magic Octopus Urn
Vous voudrez peut-être publier un lien vers l' interprète en ligne .
— Leaky Nun
Vous pouvez également utiliser à la /LJJplace de m/JdJ.
— Leaky Nun
2

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.

— Leaky Nun
source
2

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
— Fatalize
source
Je suppose que ᶜdevrait venir automatiquement avec≜
— Leaky Nun
@LeakyNun Vous ne pouvez pas exécuter ᶜseul, c'est un métaprédicat.
— Fatalize
Mais si elle est utilisée sur une liste, l'étiquetage de cette liste pourrait devenir le prédicat par défaut, non?
— mat
@mat Cela pourrait être fait de cette façon, mais pour le moment, vous ne pouvez pas utiliser de métaprédicat sur une variable.
— Fatalize
1

JavaScript, 24 octets

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

Utilise la formule de la page OEIS.

Essayez-le en ligne!

— fəˈnɛtɪk
source
Je pense que vous pouvez économiser deux octets avecx=>x**5*.55+x**3/4+x/5
— ETHproductions
@ETHproductions il y a des erreurs en virgule flottante si j'utilise * .55 au lieu de *
— 11/20
1

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.

— Stewie Griffin
source
1

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))
— acidtobi
source
Intéressant, Python 3 n'a-t-il pas des fonctions de plage plus courte que 2,7?
— Magic Octopus Urn
sum(sum(x[:3])==sum(x[3:])for x ...)serait encore plus court. Enregistre également from itertools import*un octet.
— Dennis
Vous n'avez pas besoin d'espace avant for. De plus, nous n'exigeons pas que les fonctions soient nommées par défaut, vous pouvez donc les supprimer h=.
— Dennis
1

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~!

— Pas un arbre
source
1

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.

— Luis Mendo
source
0

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.
— Chat d'affaires
source
0

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.

— NikoNyrh
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.