( liên quan )

Một bộ ba Pythagore là một danh sách (a, b, c)thỏa mãn phương trình a ² + b ² = c ² .

Một Ba nguyên thủy Pythagore (PPT) là một trong đó a, bvà ctất cả đều là nguyên tố (nghĩa là ước số chung duy nhất giữa ba yếu tố là 1). Ví dụ, (3, 4, 5)tam giác bên phải là một Ba nguyên thủy Pythagore nổi tiếng.

Các thách thức

• Cho đầu vào n, đầu ra nPPT thứ. Hoặc là,
• Cho đầu vào n, đầu ra nPPT đầu tiên .

Có nhiều cách để đặt hàng các PPT này để tạo thành một danh sách được sắp xếp tốt, để xác định đó là nthứ. Bạn có thể chọn bất kỳ thứ tự nào bạn muốn, miễn là bạn có thể chứng minh (không chính thức là tốt) rằng thuật toán của bạn có thể tạo ra mọi PPT duy nhất có thể. Ví dụ, mã của bạn không nên xuất cả hai (3,4,5)và (4,3,5)vì đó là các bản sao của cùng một bộ ba - một hoặc khác, xin vui lòng.

Tương tự, cho dù mã của bạn bằng 0 hay một chỉ mục đều ổn, miễn là bạn nêu rõ bạn đang sử dụng.

Ví dụ

Đối với các ví dụ bên dưới, tôi đang sử dụng lập chỉ mục một lần, xuất nPPT thứ và sắp xếp theo thứ tự nhỏ nhất c, sau đó nhỏ nhất a, sau đó nhỏ nhất b.

n | output
1 | (3, 4, 5)
2 | (5, 12, 13)
5 | (20, 21, 29)
12| (48, 55, 73)

Quy tắc

• Đầu vào và đầu ra có thể được đưa ra trong bất kỳ định dạng thuận tiện .
• Trong bài gửi của bạn, vui lòng cho biết các mục nhập của bạn được sắp xếp như thế nào và liệu các mục nhập của bạn được lập chỉ mục 0 hay chỉ mục 1.
• Thứ tự bạn chọn không thể tạo bản sao.
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để người khác có thể thử mã của bạn!
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Thạch , 27 25 byte

2 byte nhờ Jonathan Allan.

²IH;Pµ;ÆḊ
+2ḶḤ‘Œcg/ÐṂÇ€Ṣḣ

Hãy thử trực tuyến!

Xuất ra nbộ ba chỉ số đầu tiên [b, a, c], được sắp xếp bằng cách tăng bvà sau đó a.

Sử dụng thuật toán từ Wikipedia :

Điều này tạo ra tất cả các bộ ba nguyên thủy cho tất cả các cặp số nguyên lẻ duy nhất m > n > 0.

Giải trình

+2ḶḤ‘Œcg/ÐṂÇ€Ṣḣ    Main link. Argument: n
+2                   Add 2 to n, to get enough results.
  Ḷ                  Get integers [0, 1, ..., n+1].
   Ḥ                 Double to get [0, 2, ..., 2n+2].
    ‘                Increment to get [1, 3, ..., 2n+3].
     Œc              Get all ordered pairs [[1, 3], [1, 5], ..., [2n+1, 2n+3]].
       g/            GCD of each pair.
         ÐṂ          Grab the pairs with minimal GCD (which is 1).
           ǀ        Call the helper link on each pair to get the triples.
             Ṣ       Sort the triples first by a, then by b, then by c.
              ḣ      Get the last n.

²IH;Pµ;ÆḊ    Helper link. Argument: pair [m, n]
²              Square to get [m², n²].
 I             Increments: get [m²-n²].
  H            Halve: get [(m²-n²)/2], i.e. [b].
    P          Product: get mn, i.e. a.
   ;           Append to get [b, a].
     µ         Begin a new monadic chain with argument [b, a].
       ÆḊ      Get the length of the vector, i.e. c.
      ;        Append to get [b, a, c].

MATL , 36 byte

`@:Ut&+wmR&fZd1Mhw/vXutnGE<]GY)t&2|h

Đầu vào là 1 dựa trên. Thứ tự đầu ra đảm bảo rằng mỗi bộ ba xuất hiện chính xác một lần. Thứ tự được giải thích sau đây. Việc giải thích đòi hỏi một chút về cách thức hoạt động của chương trình.

Mã tiếp tục tăng một bộ đếm ktrong một vòng lặp, bắt đầu từ 1. Đối với mỗi knó tạo ra tất cả các cặp với a = 1,...,k, b = 1,...,k, a < b, và chọn những người cung cấp cho một Pythagore triple với c <= k. Các cặp được lấy theo thứ tự tăng dần b, sau đó a.

Mỗi cặp sau đó được chia bởi gcd của nó. Các cặp kết quả (có thể trùng lặp) được sắp xếp dưới dạng ma trận hai cột. Ma trận này được nối theo chiều dọc với một ma trận tương tự chứa các kết quả tích lũy thu được cho các giá trị nhỏ hơn của k. Các hàng của ma trận sau đó được lặp lại ổn định. Điều này loại bỏ hai loại trùng lặp:

1. Các cặp đã được tìm thấy nhiều lần cho dòng điện k(chẳng hạn như 3,4, cũng là kết quả từ 6,8khi chia cho gcd của nó);

2. Các cặp đã được tìm thấy với nhỏ hơn k.

Trong thực tế, mỗi lần lặp lại ktìm thấy tất cả các cặp đã được tìm thấy cho các lần lặp trước đó. Nhưng nó có thể tìm thấy chúng theo một thứ tự khác . Ví dụ, k=25sẽ tìm thấy bộ ba 7,24,25và không 20,21,29(vì ckhông thể vượt quá k). Sau đó, lặp đi lặp lại k=29sẽ tìm thấy cả hai, nhưng với 20,21,29 trước đó 7,24,25 (thứ tự đang tăng lên b, sau đó a). Đây là lý do tại sao, thay vì giữ tất cả các cặp mới nhất k, chúng tôi nối chúng với các cặp trước đó và lặp lại một cách ổn định. Làm như vậy đảm bảo rằng thứ tự là giống nhau cho bất kỳ đầu vào n.

Những điều trên đảm bảo rằng mỗi bộ ba Pythagore nguyên thủy cuối cùng sẽ xuất hiện, và nó sẽ chỉ xuất hiện một lần. Đối với đầu vào n, vòng lặp kkết thúc khi có ít nhất nba lần hợp lệ; và sau đó bộ nba thứ ba là ouput.

Hãy thử trực tuyến!

Hoặc sử dụng mã sửa đổi này để xem các nbộ ba đầu tiên :

`@:Ut&+wmR&fZd1Mhw/vXutnGE<]G:Y)tU&2sX^h

Hãy thử trực tuyến!

Haskell , 98 byte

f 0=(3,4,5)
f n|let(a,b,c)=f$div(n-1)3;r=mod n 3;d=a*(-1)^2^r;e=b*(-1)^r;s=2*(d+e+c)=(s-d,s-e,s+c)

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Điều này diễn giải cơ sở sinh học - 3 chữ số của n như một đường dẫn xuống cây của bộ ba Pythagore nguyên thủy . Nó chạy mà không tìm kiếm trong các hoạt động O (log n ).

Thạch , 19 18 byte

*g/²_/
4*œc3UṢÇÐḟḣ

Chương trình lấy chỉ số n dựa trên 1 và in n PPT đầu tiên [c, b, a] theo thứ tự từ điển.

Đây là giải pháp O (64 ⁿ ) , vì vậy TIO sẽ bóp nghẹt đầu vào 4 trở lên. Tôi sẽ làm việc để làm cho nó nhanh hơn.

Hãy thử trực tuyến!

Phiên bản thay thế, O (n ³ ), có thể hợp lệ

Để tìm bộ ba ^thứ n - [c _n , b _n , a _n ] - giải pháp trên giả định rằng c _n ≤ 4 ⁿ , rất dễ xác minh. Tuy nhiên, A020882 chứng minh rằng c _n ~ 2πn , do đó có một k sao cho c _n ≤ kn cho tất cả n .

Nếu chúng ta có thể lấy k = 7 , giải pháp bên dưới cũng hợp lệ (và nhanh hơn nhiều, nhanh hơn nhiều).

*g/²_/
×7œc3UṢÇÐḟḣ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

4*œc3UṢÇÐḟḣ  Main link. Argument: n

4*           Compute 4**n, the n-th power of 4.
  œc3        Take all 3-combinations of the set {1, ..., 4**n}, each sorted in
             ascending order. The triples themselves are sorted lexicographically.
     U       Upend; reverse each triple [a, b, c], yielding [c, b, a].
      Ṣ      Sort the descending triples lexicographically. This ensures that their
             order is independent of n.
       ÇÐḟ   Keep only triples for which the helper link returns a falsy value.
          ḣ  Dyadic head; take the first n triples.


*g/²_/       Helper link. Argument: [c, b, a]

 g/          Reduce [c, b, a] by greatest common divisor, yielding g.
*            Elevate the integers to that power, computing [c**g, b**g, a**g].
   ²         Square, yielding [c**2g, b**2g, a**2g].
    _/       Reduce by subtraction, yielding c**2g - b**2g - a**2g.
             Fermat's Last Theorem assures that this difference will be non-zero
             whenever g > 1, so this yields 0 iff g = 1 and c² = a² = b².

JavaScript (ES7), 106 105 103 byte

Xuất ra PPT thứ N. Kết quả được lập chỉ mục 1 và được sắp xếp theo giá trị của b .

n=>(g=(a,b)=>b?g(b,a%b):a,F=a=>(x=a*a+b*b,c=x**.5|0)*c-x*g(a,g(b,c))||--n?F(a-b?a+1:!++b):[a,b,c])(b=1)

Bản giới thiệu

let f =

n=>(g=(a,b)=>b?g(b,a%b):a,F=a=>(x=a*a+b*b,c=x**.5|0)*c-x*g(a,g(b,c))||--n?F(a-b?a+1:!++b):[a,b,c])(b=1)

for(n = 1; n <= 20; n++) {
  console.log('#' + n + ' : ' + f(n));
}

MATL , 63 byte

3lvi:"t"[HlHllO;aOlOHl]!@Y*2eh]]!XuGY)&*tt[lO;Oa]*ssD2)ED2Xy*ss

Hãy thử trực tuyến!

Một bài học về golf đã đi sai lầm khủng khiếp. Dù sao tôi cũng đang đăng nó vì tôi tự hỏi liệu có cách nào để chơi golf này tốt hơn không.

Tôi dựa trên trang Wikipedia này kết hợp với công thức của Euclid, để tạo ra tất cả các bộ ba thay vì các phương pháp thử và sai.

Đầu tiên, các cặp coprime lẻ được tạo ra như một cây ternary. Điều này được thực hiện như một phép nhân ma trận lớn, chiếm phần lớn số byte. Sau đó, công thức của Euclid được áp dụng, cũng có thể theo cách rất lãng phí byte. Nếu bất cứ ai có lời khuyên cho hai phần này, tôi rất muốn nghe chúng.

Lưu ý rằng, để lưu byte, chương trình này tạo ra một cây có cùng độ sâu với đầu vào, chứ không phải log3(n). Ngoài ra, trẻ em được tạo cho mỗi hàng thay vì chỉ cho hàng cuối cùng của cây, và sau đó được lọc lại với Xu. Quá nhiều cho một cách tiếp cận xây dựng hiệu quả.

3lv % Push root node of ternary tree
i:" % Generate a tree of depth of input (WAY too large, but golfy)
t"  % loop over all nodes (golfier than looping over last tree row)
[HlHllO;aOlOHl]! % Matrix to generate three children of current node
@Y* % Multiply with current node to get children
2e  % Reshape to get node pairs
h]] % Append to tree, exit loops
!Xu % Remove duplicates (more efficient to do it before last ] but golfier this way)
GY) % Select n-th odd coprime pair
&*tt % Multiply with it's own transpose to get [m²,m*n;m*n,n²]
[lO;Oa]*ssD % Sum of matrix multiplication = m²-n² to get a
2)ED % Second element doubled for b=2mn
2Xy*ss % Sum of matrix multiplication with identify matrix to get c=m²+n²

Haskell, 65 byte

([(a,b,c)|c<-[5..],b<-[1..c],gcd c b<2,a<-[1..b],a^2+b^2==c^2]!!)

Lập chỉ mục dựa trên 0. Đối với một cho trước c, bchạy lên cvà alên đến b, vì vậy c > b > aluôn luôn giữ.

Hãy thử trực tuyến!

Python, 67 50 48 46 byte

Sử dụng các công thức được tìm thấy trên wikipedia,

a=m*n, b=(m^2-n^2)/2, c=(m^2+n^2)/2

nơi m>n>0và mvà nlà coprimes và lẻ. Đây là mã

lambda n:[3+2*n,~-(3+2*n)**2-1/2,-~(3+2*n)**2/2]

-17 byte nhờ @Martin Ender

Dùng thử trực tuyến

Hoạt động bằng cách luôn luôn có giá trị của nbiến trong phương trình là 1, có nghĩa mđơn giản là bất kỳ giá trị lẻ nào khác, trong trường hợp này, 3+2*ntrong đó nlà số của bộ ba Pythagore nguyên thủy. Điều này cho phép chúng ta giả sử giá trị 1 cho tất cả các ngiá trị.

Husk , 18 byte

↑üOf§=F⌋ȯ¬Ḟ-m□ΠR3N

Hãy thử trực tuyến!

-4 byte cảm ơn Zgarb, với cảm hứng từ Dennis

Phương pháp tiếp cận vũ phu siêu chậm, sẽ không hoạt động trên TIO cho các đầu vào lớn hơn 1. Bạn có thể thử phiên bản dễ quản lý hơn, giới hạn ở a, b≤200 tại đây

Giải trình

↑üOf§=F⌋ȯ¬Ḟ-m□ΠR3N
              ΠR3N   Get all triples of natural numbers
   f                 Keep only those triples where
      F⌋                their GCD
    §=                  is equal to
        ȯ¬Ḟ-m□          the logical negation of c²-b²-a²
 üO                  Remove duplicates by their sorted version
↑                    Get the first <input> values of this sequence

Toán học, 89 byte

sử dụng Solve theo lệnh của c

SortBy[{a,b,c}/.Solve[a^2+b^2==c^2&&GCD[a,b]==1&&0<a<b<c<9#,{a,b,c},Integers],Last][[#]]&

Toán học, 124 byte

(s={};Table[If[IntegerQ[c=Sqrt[a^2+b^2]]&&GCD[a,b]==1,AppendTo[s,{a,b,c}]],{a,9#},{b,9#}];SortBy[Union[Sort/@s],Last][[#]])&

R (+ số), 88 byte

n=scan();while(all(nrow(T)<n))T=numbers::pythagorean_triples(5,5+(F<-F+1));T[n,3:5]

Để sử dụng một nội trang để tạo ra các số, thực sự cần một lượng byte đáng ngạc nhiên để có được những gì chúng ta muốn. Các BUILTIN nhận hai đối số c1và c2, và trả về những ba có c >= c1 & c <= c2. Điều này làm cho nó hơi khó chịu để đi đến nbộ ba -th. Điều này sẽ tiếp tục tăng c21 tại một thời điểm cho đến khi đầu ra chỉ đủ hàng.

PHP , 273 byte

function t($n){$x=[];for($c=3;;$c++)for($b=2;$b<$c;$b++)for($a=2;$a<$b;$a++)if(d($a,$b,$c)&&$a**2+$b**2==$c**2){$x[]=[$a,$b,$c];if(--$n==0)return $x;}}function d($a,$b,$c){for($i=2;$i<$a;$i++)if($a%$i==0&&$b%$i==0||$a%$i==0&&$c%$i==0||$b%$i==0&&$c%$i==0)return 0;return 1;}

• t($n) trả về một mảng [a, b, c] với thứ tự a < b < c
• Trả về chỉ mục dựa trên zero

Hãy thử trực tuyến! (mã cũng có thể đọc được)

C, 158 byte

Tôi tin rằng đây là lần gửi đầu tiên của tôi ở đây, vì vậy bạn hầu như có thể làm tốt hơn.

#include<stdio.h>
void f(n){int i=0,j=3,k,l;while(1){for(k=1;k<j;k++){for(l=k;l<j;l++){if(j*j==k*k+l*l)i++;if(i==n){printf("%d %d %d",j,k,l);return;}}}j++;};}

Và phiên bản chưa được chỉnh sửa:

#include <stdio.h>

void f(n)
{
  int i=0, j=3, k, l;
  while (1) {
    for (k=1; k<j; k++) {
      for (l=k; l<j; l++) {
        if (j*j==k*k+l*l)
          i++;
        if (i==n) {
          printf("%d %d %d\n", j, k, l);
          return;
        }
      }
    }
    j++;
  };
}

void main()
{
  int i;

  scanf("%d", &i);

  f(i);
  printf("\n");
}

Với a ² + b ² = c ² , thứ tự tăng c sau đó tăng a .

Thạch , 27 25 byte

⁽0(ḃs
Ɠḃd2Ḥ’×€Ç
3r5DṭÇæ×/

Đây là một cách thực hiện phương pháp tiếp cận cây từ câu trả lời Haskell của @ AndersKaseorg , với một trật tự chi nhánh khác. Chương trình sử dụng lập chỉ mục dựa trên 0 và lấy đầu vào từ STDIN.

Hãy thử trực tuyến!

Lý lịch

Như đã đề cập trên trang Wikipedia Cây của bộ ba Pythagore nguyên thủy , mọi PPT có thể thu được bằng cách nhân trái nhiều lần các vectơ hàng (3, 4, 5) bằng ma trận với các thuộc tính nhất định.

Trong mỗi lần lặp lại, kết quả trước đó có thể được nhân trái với A , B hoặc C , có thể được chọn như sau.

Khi A , B và C cố định, mỗi PPT có thể thu được theo một kiểu duy nhất.

Làm thế nào nó hoạt động

3r5DṭÇæ×/  Main link. No arguments.

3          Set the argument and the return value to 3.
 r5        Create a range from 3 to 5, i.e., [3, 4, 5].
   D       Decimal; convert each integer to base 10, yielding [[3], [4], [5]].
     Ç     Call the second helper link with argument 3.
    ṭ      Tack; append [[3], [4], [5]] to the result.
      æ×/  Reduce by matrix multiplication.

Ɠḃd2Ḥ’×€Ç  Second helper link. Argument: 3

Ɠ          Read and evaluate one line of input, yielding an integer n.
 ḃ         Convert n to bijective base 3.
  d2       Divmod 2; map each digit d to [d/2, d%2].
    Ḥ      Unhalve; multiply the results by 2.
     ’     Decrement the doubled results.
           The previous four atoms apply the following mapping to the digits.
               1 -> [0, 1] -> [0, 2] -> [-1,  1]
               2 -> [1, 0] -> [2, 0] -> [ 1, -1]
               3 -> [1, 1] -> [2, 2] -> [ 1,  1]
        Ç  Call the helper link with argument 3, yielding the following 2D array.
               [[ 1,  2,  2],
                [ 2,  1,  2],
                [ 2,  2,  3]]
      ×€   Multiply each [-1,  1], [ 1, -1], and [ 1,  1] by that matrix, using
           vectorizing multiplication (not matrix multiplication), yielding one 
           of the following three 2D arrays.

               [[-1,  2,  2],    [[ 1, -2,  2],    [[ 1,  2,  2],
                [-2,  1,  2],     [ 2, -1,  2],     [ 2,  1,  2],
                [-2,  2,  3]]     [ 2, -2,  3]]     [ 2,  2,  3]]

⁽0(ḃs      First helper link. Argument: 3

⁽0(        Numeric literal; yield 13041.
   ḃ       Convert 13041 to bijective base 3, yielding [1, 2, 2, 2, 1, 2, 2, 2, 3].
    s      Split the result into chunks of length 3, yielding the aforementioned
           2D array.

APL (NARS), 90 ký tự, 180 byte

{a⊃⍨⍵⊃⍋↑¨a←{⍵[⍋⍵]}¨a/⍨{1=∨/⍵}¨a←{(-/k),(×/2,⍵),+/k←⍵*2}¨a/⍨{>/⍵}¨a←,a∘.,a←⍳(⌊2⍟2+⍵)×9+⌊√⍵}

nếu đối số của hàm trên là, thì hàm trên sẽ trả về phần tử của chỉ số ⍵ (dựa trên 1) của mảng có các phần tử bộ ba Pythagore (a, b, c) trong đó a <= b <= c và mảng đó là thứ tự đầu tiên cho a, (bên ngắn hơn), sau đó cho b (bên kia không phải là cạnh huyền). Sẽ có điều gì đó không đúng vì không thấy nơi tôi đặt hàng cho b quá ... kiểm tra:

  f←{a⊃⍨⍵⊃⍋↑¨a←{⍵[⍋⍵]}¨a/⍨{1=∨/⍵}¨a←{(-/k),(×/2,⍵),+/k←⍵*2}¨a/⍨{>/⍵}¨a←,a∘.,a←⍳(⌊2⍟2+⍵)×9+⌊√⍵}
  f¨1..10
3 4 5  5 12 13  7 24 25  8 15 17  9 40 41  11 60 61  12 35 37  13 84 85  15 112 113  16 63 65  

nó có liên quan với http://oeis.org/A020884 và http://oeis.org/A020884/b020884.txt

A020884: Đặt hàng chân ngắn của tam giác Pythagore nguyên thủy.

  ↑¨f¨1..23
3 5 7 8 9 11 12 13 15 16 17 19 20 20 21 23 24 25 27 28 28 29 31 
  f 999
716 128163 128165 
  f 1000
717 28556 28565 

Tôi không biết có đúng không, có vẻ như hàm cho kết quả chính xác của cạnh thứ nhất cho đến 1000 nhưng tôi không biết phần còn lại, và có thể có thể là một số ba không đúng thậm chí <1000.

JavaScript, 101 byte

Theo công thức Euclid của tất cả các bộ ba Pythagore nguyên thủy có thể được tạo ra từ các số nguyên mvà nvới m>n>0, m+nlẻ gcd(m,n)==1( Wikipedia )

Hàm này liệt kê tất cả các m,ncặp tăng m bắt đầu từ m=2và giảm dần nbằng 2 bắt đầu từ m-1(vì vậy m+nlà số lẻ)

c=>eval("g=(a,b)=>b?g(b,a%b):a;for(m=2,n=1;c-=g(m,n)<2;(n-=2)>0||(n=m++));[m*m-n*n,2*m*n,m*m+n*n]")

Ít chơi gôn

c => {
  g = (a,b) => b ? g(b,a%b) : a;
  for( m = 2, n = 1; 
       g(m,n) < 2 ? --c : c; 
       (n -= 2) > 0 || (n = m++))
    /* empty for body */;
  return [m*m - n*n, 2*m*n, m*m + n*n]
}

Kiểm tra

F=
c=>eval("g=(a,b)=>b?g(b,a%b):a;for(m=2,n=1;c-=g(m,n)<2;(n-=2)>0||(n=m++));[m*m-n*n,2*m*n,m*m+n*n]")

for(i=1;i<=50;i++) console.log(i+' '+F(i))