Definizione

Un "triangolo intero" è uno con coordinate intere. Ad esempio il seguente triangolo è un triangolo intero:

(0, 0), (0, 1), (1, 2) with perimeter 1 + sqrt(2) + sqrt(5) ≈ 4.650.

Compito

L'obiettivo di questa sfida è contare tutti i triangoli interi (fino alla congruenza) con un perimetro inferiore a n.

Ingresso e uscita

L'argomento verrà fornito come un numero intero e l'output dovrebbe essere il numero di triangoli con perimetro strettamente inferiore all'argomento.

Esempi

Il triangolo intero più piccolo per perimetro è congruente

(0, 0), (0, 1), (1, 0) which has perimeter 2 + sqrt(2) ≈ 3.414

I prossimi più piccoli sono:

(0, 0), (0, 1), (1, 2) with perimeter 1 + sqrt(2) + sqrt(5) ≈ 4.650,
(0, 0), (0, 2), (1, 1) with perimeter 2 + 2sqrt(2)          ≈ 4.828,
(0, 0), (0, 2), (1, 0) with perimeter 3 + sqrt(5)           ≈ 5.236, and
(0, 0), (1, 2), (2, 1) with perimeter sqrt(2) + 2sqrt(5)    ≈ 5.886

Casi test:

a(1) = 0
a(2) = 0
a(3) = 0
a(4) = 1
a(5) = 3
a(6) = 5
a(7) = 11
a(8) = 18
a(9) = 29
a(10) = 44
a(12) = 94
a(20) = 738
a(30) = 3756
a(40) = 11875

Ho coordinate per ciascuno dei triangoli in questo Gist .

Avvertenze

Si noti che due triangoli non congruenti possono avere lo stesso perimetro:

(0, 0), (0, 3), (3, 0) and (0, 0), (0, 1), (3, 4) both have perimeter 6 + 3sqrt(2).

Tieni inoltre presente che la disuguaglianza è rigorosa ; il triangolo pitagorico 3-4-5 dovrebbe essere contato da un (13), non un (12).

punteggio

Questo è code-golf: vince il codice più corto!

Gelatina , 28 27 25 23 byte

pḶŒcÆḊÐfḅı;I$€AṢ€QS€<¹S

Provalo online!

Come funziona

pḶŒcÆḊÐfḅı;I$€AṢ€QS€<¹S  Main link. Argument: n

 Ḷ                       Unlength; yield [0,...,n-1].
p                        Take the Cartesian product of [1,...,n] and [0,...,n-1].
  Œc                     Take all combinations of the resulting pairs.
                         The result are of the form [[a, b], [c, d]].
    ÆḊÐf                 Filter by determinant; keep only pairs of pairs for which
                         the determinant (ad - bc) is non-zero, i.e., those such
                         that [0, 0], [a, b], and [c, d] are not collinear.
        ḅı               Convert each pair [a, b] from base i (imaginary unit) to
                         integer, mapping it to ai + b.
             €           For each pair of complex numbers [p, q]: 
          ;I$              append their forward differences, yielding [p, q, p-q].
              A          Take the absolute value of each resulting complex number.
               Ṣ€        Sort each resulting array of side lengths.
                 Q       Unique; remove duplicates.
                  S€     Take the sum of each array, computing the perimeters.
                    <¹   Compare them with n.
                      S  Take the sum of the resulting Booleans.

Gelatina ,  38  33 byte

-1 grazie a Erik the Outgolfer (invertire SP¬+÷/E$usando SẠ>÷/E$e usare ÇÐfpiuttosto che ÇÐḟ) -1 grazie a Mr. Xcoder (non è necessario appiattire prima dell'ordinamento )
-2 grazie a Mr. Xcoder ( S<¥Ðf³L-> S€<³S)
-1 rubare un trucco da una precedente revisione della risposta di Dennis ( ṗ2’Œc-> p`⁺’- casi più ridondanti ma più golfisti!)

SẠ>÷/E$
p`⁺’ÇÐfµ_/ṭ⁸²S€Ṣµ€Q½S€<³S

Un programma completo che prende un numero intero e stampa il risultato.

Provalo online! (troppo lento per completare i casi di test 20+ in meno di 60 anni)

Come?

SẠ>÷/E$ - Link 1, straightLineFromOrigin?: coordinates       i.e. [[a,b],[c,d]]
S       - sum                                                     [a+c,b+d]
 Ạ       - all? (0 if either of a+c or b+d are 0 otherwise 1)      all([a+c,b+d])
      $ - last two links as a monad:
   ÷/   -   reduce by division                                    [a÷c,b÷d]
     E  -   all equal?  (i.e. 1 if on a non-axial straight line)  a÷c==b÷d 
  >     - greater than? (i.e. 1 if not on any line, 0 otherwise)  all([a+c,b+d])>(a÷c==b÷d)

p`⁺’ÇÐḟµ_/ṭ⁸²S€Ṣµ€Q½S€<³S - Main link: integer, n
p`                        - Cartesian product of implicit range(n) with itself
  ⁺                       - repeat (Cartesian product of that result with itself)
   ’                      - decrement (vectorises)
                          -  - i.e. all non-negative lattice point pairs up to x,y=n-1
     Ðf                   - filter keep only if:
    Ç                     -   call last link (1) as a monad
       µ         µ€       - monadic chain for €ach:
        _/                -   reduce with subtraction i.e. [a-c,b-d]
           ⁸              -   chain's left argument, [[a,b],[c,d]]
          ṭ               -   tack                   [[a,b],[c,d],[c-a,d-b]]
            ²             -   square (vectorises)    [[a²,b²],[c²,d²],[(c-a)²,(d-b)²]]
             S€           -   sum €ach               [[a²+b²],[c²+d²],[(c-a)²+(d-b)²]]
                          -    - i.e. the squares of the triangle's edge lengths
               Ṣ          -   sort
                  Q       - de-duplicate (get one of each congruent set of triangles)
                   ½      - square root (vectorises)  - get sides from squares of sides
                    S€    - sum €ach
                       ³  - program's 3rd argument, n
                      <   - less than?
                        S -   sum (number of such triangles)
                          - implicit print

JavaScript (ES7), 157 byte

f=(n,i=n**4,o={})=>i--&&([p,P,q,Q]=[0,1,2,3].map(k=>i/n**k%n|0),!o[k=[a=(H=Math.hypot)(p,P),b=H(p-q,P-Q),c=H(q,Q)].sort()]&a+b+c<n&&(o[k]=P*q!=p*Q))+f(n,i,o)

Casi test

Solo i valori piccoli possono essere calcolati con la dimensione dello stack predefinita della maggior parte dei motori JS.

f=(n,i=n**4,o={})=>i--&&([p,P,q,Q]=[0,1,2,3].map(k=>i/n**k%n|0),!o[k=[a=(H=Math.hypot)(p,P),b=H(p-q,P-Q),c=H(q,Q)].sort()]&a+b+c<n&&(o[k]=P*q!=p*Q))+f(n,i,o)

;[
  1,  // 0
  2,  // 0
  3,  // 0
  4,  // 1
  5,  // 3
  6,  // 5
  7,  // 11
  8,  // 18
  9   // 29
]
.forEach(n => console.log('a(' + n + ') = ' + f(n)))

Versione non ricorsiva, 165 byte

n=>[...Array(n**4)].reduce((x,_,i,o)=>x+=!o[[p,P,q,Q]=[0,1,2,3].map(k=>i/n**k%n|0),k=[a=(H=Math.hypot)(p,P),b=H(p-q,P-Q),c=H(q,Q)].sort()]&(o[k]=P*q!=p*Q)&a+b+c<n,0)

Casi test

Questa versione funziona anche per un (30) e un (40) , ma ciò richiederebbe troppo tempo per lo snippet.

let f =

n=>[...Array(n**4)].reduce((x,_,i,o)=>x+=!o[[p,P,q,Q]=[0,1,2,3].map(k=>i/n**k%n|0),k=[a=(H=Math.hypot)(p,P),b=H(p-q,P-Q),c=H(q,Q)].sort()]&(o[k]=P*q!=p*Q)&a+b+c<n,0)

;[
  1,  // 0
  2,  // 0
  3,  // 0
  4,  // 1
  5,  // 3
  6,  // 5
  7,  // 11
  8,  // 18
  9,  // 29
  10, // 44
  12, // 94
  20  // 738
]
.forEach(n => console.log('a(' + n + ') = ' + f(n)))

Julia 0.6 , 135 byte

Scorrere i possibili punti di non origine per formare il triangolo, rappresentarli come numeri complessi, ordinare le lunghezze dei quadrati e tenerli in un set per verificare la congruenza. Evita i punti colinear controllando che l'angolo tra i loro numeri complessi sia diverso da zero. Quindi restituisce la lunghezza dell'insieme. È più breve usare direttamente le lunghezze, ma ottieni la risposta sbagliata per a(40). La soluzione è troppo lenta per essere eseguita a a(40)causa di un avviso di deprecazione, quindi ho anche un collegamento a una versione più veloce.

n->(q=Set();for x=0:n,y=1:n,a=1:n,b=0:n
r=x+y*im
t=a+b*im
g=sort(abs2.([r,t,r-t]))
sum(√g)<n&&angle(r/t)>0&&push!(q,g)
end;length(q))

Provalo online!

Versione più veloce, più lunga con deprecazione evitata. Provalo online! Utilizza sqrt.(g)al posto di deprecato √gper radice quadrata elementally.

Pulito , 227 ... 143 byte

import StdEnv
@n#l=[0.0..n]
=sum[1\\p<-removeDup[sort(map(sqrt o\[u,v]=u*u+v*v)[[a-i,b-j],[a,b],[i,j]])\\a<-l,b<-l,i<-l,j<-l|a*j<>i*b]|sum p<n]

Provalo online!

Rileva triangoli congruenti confrontando i tre valori che sommano per formare il perimetro e i punti colineari verificando che i due valori più piccoli non si sommino al terzo.

Ecco una versione che utilizza un approccio più veloce, più pesante per la memoria: provalo online!