L'uguaglianza viene in tre

11

Tratto da: OEIS- A071816

Il tuo compito, dato un limite superiore di n, è trovare il numero di soluzioni che soddisfano l'equazione:

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

La sequenza inizia come descritto nella pagina OEIS e come di seguito (1 indicizzato):

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

Per n = 1, c'è solo una soluzione:(0,0,0,0,0,0)

Per n = 2, ci sono 20 soluzioni ordinate (a,b,c,x,y,z)per 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'input è un singolo intero che indica n.
  • L'output è un singolo intero / stringa che indica f(n), dove f(...)è la funzione sopra.
  • L'indicizzazione è esattamente come descritta, nessun'altra indicizzazione è accettabile.

Questo è code-golf , vince il conteggio dei byte più basso.

code-golf  number  sequence 
— Urna di polpo magico
fonte
Ahhh crappp, non ho notato la formula diretta su OEIS, ho pensato che non sarebbe stato così facile. Vabbè, non sto facendo +1 sui porti diretti di quell'equazione; P.
— Magic Octopus Urn
1
Almeno la formula non era perfettamente giocata: P
— fəˈnɛtɪk,
Poi di nuovo, dà una possibilità ai reg-lang contro gli eso-lang.
— Magic Octopus Urn,
Sarebbe meglio se il titolo fosse "l'uguaglianza arriva in terzine"?
— Leaky Nun

Risposte:

11

Gelatina , 9 6 byte

ṗ6ḅ-ċ0

O (n 6 ) soluzione.

Provalo online!

Come funziona

ṗ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
fonte
Ha! Devo amare le risposte teoriche (la mia base per una risposta teorica è ora che funziona su TIO per grandi valori di n , questo è probabilmente un male). Speravo di vedere un O(n^6)pensiero: P.
— Magic Octopus Urn,
9

Mathematica 17 o 76 byte

Utilizzando la formula:

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

(Salvato 3 byte per @GregMartin e @ngenisis)

Piuttosto che usare la formula, qui calcolo letteralmente tutte le soluzioni e le conto.

Length@Solve[a+b+c==x+y+z&&And@@Table[(0<=i<#),{i,{a,b,c,x,y,z}}],Integers]&
— Kelly Lowder
fonte
2
Grazie per aver pubblicato il modo non-forza bruta :). +1 per qualsiasi risposta di matematica che non sia un'equazione o un incorporato.
— Magic Octopus Urn,
In base a questa risposta , puoi sostituirlo 11/20con .55un risparmio di due byte.
— Greg Martin,
Inoltre, non è necessario l'asterisco nel primo termine.
— ngenisi,
8

Haskell , 48 byte

Non ho notato la formula prima di scrivere questo, quindi sicuramente non è il metodo generale più breve (o più veloce), ma ho pensato che fosse carino.

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

Provalo online!

f ngenera tutti gli elenchi di 6 elementi da [1..n], quindi conta quelli la cui somma alternata è 0. Utilizza il fatto che a+b+c==d+e+fè lo stesso di a-(d-(b-(e-(c-f))))==0, e anche che non importa se aggiungiamo un 1 a tutti i numeri.

— Ørjan Johansen
fonte
Ho notato che, spesso, la risposta più breve è la meno impressionante;). Questo è un uso piuttosto interessante di fold che non avrei considerato prima di vedere questa risposta.
— Magic Octopus Urn,
6

MATL , 12 byte

l6:"G:gY+]X>

Provalo online!

Spiegazione

Non potevo perdere l'occasione di usare di nuovo la convoluzione!

Questo utilizza la seguente caratterizzazione di OEIS:

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

e naturalmente la moltiplicazione polinomiale è convoluzione.

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
fonte
5

Gelatina , 9 byte

ṗ3S€ĠL€²S

Non breve come @ Dennis's, ma termina in meno di 20 secondi per l'input 100.

Provalo online!

Come funziona

ṗ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
fonte
Puoi spiegare questo metodo? Attualmente sto imparando Jelly, ma non sono ancora abbastanza bravo da inviare risposte reali; Ti guardo sempre, Dennis e pochi altri per buoni esempi.
— Magic Octopus Urn,
@carusocomputing Hai completato la spiegazione. Fammi sapere se hai ancora domande :-)
— ETHproductions
Fantastico, sono per lo più confuso sull'ottimizzazione delle risposte dall'implementazione di base della forza bruta che farei al pazzo codice corto che vedo postare voi ragazzi; ma credo che ogni spiegazione sia un passo avanti grazie!
— Magic Octopus Urn,
5

Pyth, 13 12 byte

JsM^UQ3s/LJJ

Salvato un byte grazie a Leaky Nun.

Spiegazione

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 per non usare la formula diretta: P.
— Magic Octopus Urn
Potresti pubblicare un link all'interprete online .
— Leaky Nun,
Inoltre, puoi usare /LJJinvece di m/JdJ.
— Leaky Nun,
2

Oasi , 17 byte

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

Provalo online!

Oasis è un linguaggio basato su stack ottimizzato per sequenze ricorrenti. Tuttavia, la formula di ricorsione sarebbe troppo lunga per questo caso.

— Perdente Suora
fonte
2

Brachylog , 17 byte

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

Provalo online!

Spiegazione

{  |↰}ᶠ⁶           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
fonte
Immagino che ᶜdovrebbe venire automaticamente con≜
— Leaky Nun
@LeakyNun Non puoi correre ᶜda solo, è un metapredicato.
— Fatalizza il
Ma comunque se viene utilizzato in un elenco, l'etichettatura di tale elenco potrebbe diventare il predicato predefinito, no?
— mat
@mat Potrebbe essere fatto in questo modo, ma in questo momento non è possibile utilizzare un metapredicato su una variabile.
— Fatalizza
1

JavaScript, 24 byte

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

Utilizza la formula dalla pagina OEIS.

Provalo online!

— fənɛtɪk
fonte
Penso che puoi salvare due byte conx=>x**5*.55+x**3/4+x/5
— ETHproductions
@ETHproductions ci sono errori in virgola mobile se uso * .55 invece di *
— 11/20
1

Ottava , 25 23 21 byte

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

Provalo online!

Utilizza la formula dalla voce OEIS. Hai salvato due quattro byte riorganizzando la formula e usando .55invece di 11/20, grazie a fəˈnɛtɪk.

— Stewie Griffin
fonte
1

Python 2.7, 109 105 99 96 byte

Grazie ETHproductions e Dennis per aver salvato qualche byte:

from itertools import*
lambda s:sum(sum(x[:3])==sum(x[3:])for x in product(range(s),repeat=6))
— acidtobi
fonte
Interessante, Python 3 non ha funzioni di intervallo più brevi di 2.7?
— Magic Octopus Urn,
sum(sum(x[:3])==sum(x[3:])for x ...)sarebbe ancora più breve. Inoltre, from itertools import*salva un byte.
— Dennis,
Non hai bisogno dello spazio prima for. Inoltre, non è necessario che le funzioni vengano denominate per impostazione predefinita, quindi è possibile rimuoverle h=.
— Dennis,
1

Mathematica, 52 byte

L'implementazione della formula OEIS di Kelly Lowder è molto più breve, ma questo calcola direttamente i numeri:

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

Bene, in realtà conta il numero di soluzioni con 1 <= a,b,c,x,y,z <= n. Questo è lo stesso numero, poiché l'aggiunta di 1 a tutte le variabili non modifica l'uguaglianza.

Spiegazione: Range@#~Tuples~6crea tutte le liste di sei numeri interi tra 1 e n, #~Partition~3&/@suddivide ciascuna lista in due liste di lunghezza 3, Tr/@somma queste liste secondarie e Count[...,{n_,n_}]conta quante coppie hanno la stessa somma. Sono stato molto fortunato con l'ordine di precedenza tra f @, f /@e ~f~!

— Non un albero
fonte
1

Ottava , 41 byte

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

Provalo online!

Simile alla mia risposta MATL , ma calcola la convoluzione tramite una trasformata di Fourier discreta ( fft) con un numero sufficiente di punti ( n^2). ~~(1:n)è usato come una versione più breve di ones(1,n). roundè necessario a causa di errori in virgola mobile.

— Luis Mendo
fonte
0

CJam , 17 byte

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

Inserimento di 11timeout su TIO e 12memoria esaurita superiore.

Provalo online!

Spiegazione

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.
— Gatto di affari
fonte
0

Clojure, 79 byte

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

Tonnellate di ripetizione nel codice, su un numero maggiore di variabili una macro potrebbe essere più breve.

— NikoNyrh
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.