Thử thách

Cho một số nguyên dương, xác định xem đó có phải là số tam giác hay không, và theo đó xuất ra một trong hai giá trị bất biến, không đổi.

Định nghĩa

Một số tam giác là một số có thể được thể hiện dưới dạng tổng của các số nguyên dương liên tiếp, bắt đầu từ 1. Họ cũng có thể được biểu diễn bằng công thức n(n + 1) / 2, nơi nlà một số nguyên dương.

Các trường hợp thử nghiệm

Sự thật:

1
3
6
10
15
21
55
276
1540
2701
5050
7626
18915
71253
173166
222111
303031
307720
500500
998991

Giả mạo:

2
4
5
7
8
9
11
16
32
50
290
555
4576
31988
187394
501500
999999

Quy tắc

• Mục nhập của bạn có thể là một chức năng hoặc một chương trình.
• Bạn có thể cho rằng đầu vào là số nguyên dương dưới 10 ⁶ .
• Bạn phải chọn hai đầu ra không đổi, riêng biệt để phân biệt hai loại.

Đây là mã golf , vì vậy mã ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng.

Haskell , 23 byte

CHỈNH SỬA:

• -1 byte: @xnor đã loại bỏ dấu ngoặc đơn với a $.

Một hàm ẩn danh lấy Intvà trả về a Char.

Đầu ra là '1'cho số tam giác và '0'cho những người khác.

(!!)$show.(10^)=<<[0..]

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

• Sử dụng như ((!!)$show.(10^)=<<[0..]) 998991.

• Tạo các số 1, 10, 100, 1000, ..., chuyển đổi các số đó thành chuỗi và nối chúng. Sau đó lập chỉ mục vào chuỗi vô hạn kết quả

  "1101001000100001000001000000...

Python , 24 byte

lambda n:(8*n+1)**.5%1>0

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

Đầu ra False cho số tam giác, Truecho phần còn lại. Kiểm tra nếu 8*n+1là một hình vuông hoàn hảo. Python sẽ lấy các ô vuông hoàn hảo cho các số nguyên chính xác cho dù lớn đến đâu, do đó không có vấn đề về dấu phẩy động.

Thạch , 4 byte

R+\ċ

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

Làm sao?

R+\ċ - Main link: n
R    - range(n)   -> [1,2,3,...,N]
  \  - cumulative reduce by:
 +   -   addition -> [1,3,6,...,T(N)]
   ċ - count occurrences of right (n) in left -> 1 if triangular, 0 otherwise

Võng mạc , 10 byte

(^1|1\1)+$

Đầu vào là đơn nhất. Đầu ra là 0hoặc 1.

Hãy thử trực tuyến! (Là một bộ thử nghiệm thực hiện chuyển đổi thập phân sang đơn nhất để thuận tiện.)

Giải trình

Đây là bài tập cơ bản nhất trong các tài liệu tham khảo về phía trước. Hầu hết mọi người đều quen thuộc với phản hồi trong regex, vd(.)\1 để khớp với một ký tự lặp lại. Tuy nhiên, một số hương vị cao cấp hơn cho phép bạn sử dụng phản hồi trước hoặc trong nhóm mà nó đề cập đến. Trong trường hợp đó, nó thường được gọi là tham chiếu chuyển tiếp. Điều này có thể có ý nghĩa nếu tham chiếu được lặp đi lặp lại. Nó có thể không được xác định rõ trong lần lặp đầu tiên, nhưng ở các lần lặp tiếp theo, nhóm sau hoặc nhóm xung quanh đã nắm bắt được một cái gì đó và có thể được sử dụng lại.

Điều này thường được sử dụng để thực hiện các mẫu lặp lại trên các chuỗi đơn nguyên. Trong trường hợp này, chúng tôi cố gắng khớp đầu vào dưới dạng tổng của các số nguyên liên tiếp:

(        # This is group 1, which we'll repeat 1 or more times.
  ^1     #   Group 1 either matches a single 1 at the beginning of the string.
|        # or
  1\1    #   It matches whatever the previous iteration matched, plus another
         #   1, thereby incrementing our counter.
         # Note that the first alternative only works on the first iteration
         # due to the anchor, and the second alternative only works *after*
         # the first iteration, because only then the reference is valid.
)+
$        # Finally, we make sure that we can exactly hit the end of the
         # string with this process.

Python 2 , 25 byte

Kiểm tra xem ( 8x + 1 ) có phải là số vuông không.

lambda x:(8*x+1)**.5%1==0

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

Toán học, 16 byte

OddQ@Sqrt[1+8#]&

Về cơ bản là một cổng của giải pháp Python của xnor . Đầu ra Truecho số tam giác, Falsenếu không.

JavaScript (ES6), 30 27 byte

Đã lưu 2 byte nhờ kamoroso94

f=(n,k)=>n>0?f(n+~k,-~k):!n

Các trường hợp thử nghiệm

f=(n,k)=>n>0?f(n+~k,-~k):!n

console.log('Testing truthy test cases');
console.log(f(1))
console.log(f(3))
console.log(f(6))
console.log(f(10))
console.log(f(15))
console.log(f(21))
console.log(f(55))
console.log(f(276))
console.log(f(1540))
console.log(f(2701))
console.log(f(5050))
console.log(f(7626))
console.log(f(18915))
console.log(f(71253))
console.log(f(173166))
console.log(f(222111))
console.log(f(303031))
console.log(f(307720))
console.log(f(500500))
console.log(f(998991))

console.log('Testing falsy test cases');
console.log(f(2))
console.log(f(4))
console.log(f(5))
console.log(f(7))
console.log(f(8))
console.log(f(9))
console.log(f(11))
console.log(f(16))
console.log(f(32))
console.log(f(50))
console.log(f(290))
console.log(f(555))
console.log(f(4576))
console.log(f(31988))
console.log(f(187394))
console.log(f(501500))
console.log(f(999999))

Phiên bản không đệ quy (ES7), 19 byte

Câu trả lời của cảng Adnan .

x=>(8*x+1)**.5%1==0

CJam , 11 byte

ri2*_mQ_)*=

Đầu ra 1cho hình tam giác, 0nếu không.

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

Giải trình

Xem xét đầu vào 21.

ri               e# Input integer.             STACK: 21
  2*             e# Multiply by 2.             STACK: 42
    _            e# Duplicate.                 STACK: 42, 42
     mQ          e# Integer square root.       STACK: 42, 6
       _)        e# Duplicate, increment.      STACK: 42, 6, 7
         *       e# Multiply.                  STACK: 42, 42
          =      e# Equal?                     STACK: 1

Brain-Flak , 40 byte

(([{}](((()))<>))<>){<>({}({}({})))}{}{}

Wheat Wizard và tôi đã đấu tay đôi với câu hỏi này. Khi chúng tôi quyết định đăng các giải pháp của mình, chúng tôi đã bị ràng buộc ở mức 42 byte, nhưng tôi đã tìm thấy một giải pháp golf 2 byte. Chúng tôi quyết định rằng sẽ được tính là bộ ngắt kết nối (giải pháp của tôi là bên dưới).

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

Giải trình:

# Set up the stacks like this:  -input
                                     1     -input
                                     1          1
(([{}](((()))<>))<>)                 ^

# Output 1 for triangular and 0 for non-triangular 
{<>({}({}({})))}{}{}

Để được giải thích đầy đủ, vui lòng xem câu trả lời của Wheat Wizard .

Brain-Flak , 42 byte

(([({})])<>){(({}())<>{}({})){((<>))}{}{}}

Đầu ra 0\n(dòng mới theo nghĩa đen) cho sự thật và chuỗi trống cho giả.

Ý tưởng là trừ 1 rồi 2 rồi 3 cho đến đầu vào. Nếu bạn nhấn 0, thì bạn biết đây là số tam giác, vì vậy bạn có thể dừng ở đó.

Hãy thử trực tuyến! (sự thật)
Hãy thử trực tuyến! (giả)

# Push -input on both stacks. One is a counter and the other is a running total
(([({})])<>)

# Count up from -input to 0
{
  # Push the new total which is: (counter += 1) + total (popped) + input (not popped)
  # This effectively adds 1, then 2, then 3 and so on to the running total
  (({}())<>{}({}))
  # If not 0
  {
    # Push to 0s and switch stacks to "protect" the other values
    ((<>))
  # End if
  }
  # Pop the two 0s, or empty the stack if we hit 0
  {}{}
# End loop
}

Đây là một giải pháp 46 byte mà tôi thấy thú vị.

{<>(({}())){({}[()]<>{(<({}[()])>)}{}<>)}{}<>}

Đầu ra 0\n(dòng chữ mới) cho sự thật, chuỗi trống cho giả.

Ý tưởng là đếm ngược từ đầu vào bằng các số liên tiếp, 1 lần. Ví dụ input - (1) - (1,1) - (1,1,1). Mỗi lần chúng tôi trừ đi, nếu chúng tôi chưa về 0, chúng tôi sẽ để lại một giá trị bổ sung trên ngăn xếp. Theo cách đó, nếu chúng tôi ở mức 0 và vẫn bị trừ khi bật, chúng tôi sẽ xóa giá trị cuối cùng trên ngăn xếp. Nếu đầu vào là một số tam giác, chúng ta sẽ kết thúc chính xác ở 0 và sẽ không bật 0.

Hãy thử trực tuyến! sự thật
Hãy thử trực tuyến! giả

# Implicit input (call it I)

# Until we reach 0, or the stack is empty
{
  # Add 1 to the other stack and push it twice. This is our counter.
  <>(({}()))
  # While counter != 0
  {
    # counter -= 1
    ({}[()]
    # if I != 0 
    <>{
      # I -= 1, and push 0 to escape the if
      (<({}[()])>)
    # End if
    }
    # Pop from the stack with I. This is either the 0 from the if, or I
    {}
    # Get ready for next loop End while
    <>)
  # End While
  }
  # Pop the counter that we were subtracting from
  {}<>
# End Until we reach 0, or the stack is empty.
}

Thạch , 5 byte

×8‘Ʋ

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

Lý lịch

Gọi n là đầu vào. Nếu n là số tam giác ^thứ k , ta có

có nghĩa là sẽ có một giải pháp tự nhiên nếu và chỉ khi 1 + 8n là một hình vuông kỳ lạ, hoàn hảo. Rõ ràng, không cần kiểm tra tính chẵn lẻ của 1 + 8n .

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

×8‘Ʋ  Main link. Argument: n

×8     Yield 8n.
  ‘    Increment, yielding 8n + 1.
   Ʋ  Test if the result is a perfect square.

PowerShell , 31 30 byte

"$args"-in(1..1e6|%{($s+=$_)})

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

Phương pháp vũ phu đẹp và chậm. Tạo một mảng của mỗi tổng từ 1 đến 10 ⁶ và xem liệu đối số có ở đó không.

Brain-Flak , 42 byte

(([{}](<((())<>)>))<>){<>({}({}({})))}{}{}

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

Giải trình

Mục tiêu của chương trình này là tạo trạng thái trên hai ngăn xếp và thực hiện hoạt động liên tục trên cả hai ngăn xếp cho đến khi một trong số chúng không, sau đó chúng ta có thể xuất ra tùy thuộc vào ngăn xếp nào chúng ta đang ở. Điều này tương tự như các chương trình xác định dấu của một số. Các chương trình này đặt ntrên một ngăn xếp và chồng -nlên nhau và thêm một và chuyển đổi ngăn xếp cho đến khi một trong các ngăn xếp bằng không. Nếu số đó là số âm ở vị trí đầu tiên, ngăn xếp đầu tiên sẽ về 0, nếu số đó là số dương thì ngăn xếp khác sẽ về không.

Ở đây chúng ta tạo hai ngăn xếp một trừ các số liên tiếp từ đầu vào và một ngăn chỉ trừ một. Số trừ các số liên tiếp sẽ chỉ chấm dứt nếu số đó là hình tam giác, (thông minh khác, nó sẽ chỉ vượt qua 0 và tiếp tục đi vào phủ định). Số còn lại sẽ luôn chấm dứt cho bất kỳ số dương nào, nhưng sẽ luôn làm chậm hơn số đầu tiên, do đó các số không phải là tam giác sẽ chấm dứt trên ngăn xếp đó.

Vậy làm thế nào để chúng ta thiết lập các ngăn xếp sao cho cùng một thao tác trừ các số liên tiếp trên một và trừ đi một số khác? Trên mỗi ngăn xếp, chúng ta có đầu vào ở trên để có thể kiểm tra, bên dưới chúng ta có sự khác biệt và bên dưới chúng ta có sự khác biệt của sự khác biệt. Mỗi lần chạy, chúng tôi thêm "chênh lệch chênh lệch" vào "chênh lệch" thông thường và trừ đi từ đầu vào. Đối với ngăn xếp kiểm tra độ tam giác, chúng tôi đặt chênh lệch gấp đôi của chúng tôi để 1chúng tôi nhận được các số nguyên liên tiếp mỗi lần chạy, đối với ngăn xếp khác chúng tôi đặt nó để 0chúng tôi không bao giờ thay đổi chênh lệch, đó là luôn giữ nguyên 1. Đây là Làm thế nào ngăn xếp được thiết lập ở đầu, nđầu vào ở đâu:

-n  -n
 0   1
 1   0

Cuối cùng khi chúng ta chấm dứt, chúng ta có thể sử dụng các khác biệt này để kiểm tra ngăn xếp nào chúng ta đang ở trên chúng ta bật hai giá trị hàng đầu và chúng ta nhận được 1cho một số tam giác và 0cho một số không phải là tam giác.

Mã chú thích

(([{}](<((())<>)>))<>) Set up the stack
{                      While
 <>                    Switch stacks
 ({}({}({})))          Add bottom to second to bottom, add second to bottom to top
}                      End while
{}{}                   Pop the top two values

Đây là một giải pháp 50 byte tôi cũng thích.

{(({}[()]))}(([[]])<>){({}{}())<>}({}{()<><{}>}{})

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

Hình khối , 23 24 25 byte

I1Wq/)s.;0..s;p-?\.+O@u

0 cho sự thật và không có gì 0 cho falsey. Tạo lực bằng cách tăng bộ đếm, thêm vào tổng tích lũy và so sánh với đầu vào. Bây giờ để thử và lắp nó vào khối lập phương 2x2x2. Đã làm nó!

    I 1
    W q
/ ) s . ; 0 . .
s ; p - ? \ . +
    O @
    u .

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

• / Phản ánh để đối mặt.
• I10\ nhận đầu vào số nguyên, đẩy 1 (bộ đếm), đẩy 0 (tổng) và phản ánh
• +s;p-thân vòng lặp. Thêm tổng và bộ đếm, bỏ tổng trước đó, tăng đầu vào và trừ
• ? Kiểm tra kết quả của phép trừ
  • Cho 0 kết quả thực hiện thẳng về phía trước \.uO@ phản ánh đến mặt dưới, không-op, quay đầu, đầu ra và dừng lại.
  • Để có kết quả tích cực, rẽ phải vào mặt dưới và @ dừng lại
  • Đối với kết quả âm ;qWs)/su, trừ phép trừ trái , đặt đầu vào xuống dưới, dịch chuyển sang trái, bộ đếm trao đổi và tổng, bộ đếm tăng, phản xạ, tổng số trao đổi và bộ đếm, quay đầu vào thân vòng lặp chính.

05AB1E , 7 6 byte

EDIT : Cảm ơn @Dennis: Đã lưu một byte vì tôi quên mất toán tử gia tăng

8*>t.ï

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

nlà tam giác nếu sqrt(8n + 1)là một số nguyên

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

8* # multiply implicit input by 8
  > # add one
   t # sqrt
    .ï # is integer

Perl 6 , 17 byte

{$_∈[\+] 1..$_}

Chỉ cần kiểm tra xem $_, đầu vào của hàm, có bằng bất kỳ phần tử nào của phép giảm cộng tam giác hay không (1, 1+2, ..., 1+2+...+$_).

Alice , 38 22 byte

Rất nhiều byte được lưu nhờ Martin và Leo

/ i \ 2 * .2RE.h * -n / o @

Có một dòng mới. Đầu ra 1cho hình tam giác, 0nếu không.

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

Giải trình

Điều này sử dụng cách tiếp cận tương tự như câu trả lời của tôi , chỉ vụng về. Ở dạng tuyến tính, chương trình trở thành

i2*.2RE.h*-no@

trong đó ivà othực sự ở chế độ thứ tự.

Hãy xem xét đầu vào 21là một ví dụ.

i         Input integer                       STACK: 21
2*        Multiply by 2                       STACK: 42
.         Duplicate                           STACK: 42, 42
2RE       Integer square root                 STACK: 42, 6
.         Duplicate                           STACK: 42, 6, 6
h         Increment                           STACK: 42, 6, 7
*         Multiply                            STACK: 42, 42
-         Subtract                            STACK: 0
n         Logical negation                    STACK: 1
o         Output integer                      STACK:
@         End program

Japt , 10 7 byte

Đã lưu 3 byte nhờ @Luke và @ETHproductions

*8Ä ¬v1

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

Giải trình:

*8Ä ¬v1
    ¬    // Square root of:
*8       //   Input * 8
  Ä      //   +1
     v1  // Return 1 if divisible by 1; Else, return 0

õ å+ øU

Giải trình:

õ å+ øU
õ           // Create a range from [1...Input]
  å+        // Cumulative reduce by addition
     øU     // Does it contain the input?

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

R , 23 19 byte

Cách tiếp cận tương tự như các câu trả lời khác. Kiểm tra xem nếu 8x+1là một hình vuông hoàn hảo.
-4 byte cảm ơn Giuseppe và MickyT.

!(8*scan()+1)^.5%%1

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

MATL , 5 byte

t:Ysm

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

Giải trình:

t       % Duplicate input
 :      % Range(1, input)
  Ys    % Cumulative sum. This will push the first *n* triangular numbers
    m   % ismember. Pushes true if the input is contained within the array we just pushed

Mẻ, 72 byte

@set/aj=i=0
:l
@if %1% gtr %j% set/aj+=i+=1&goto l
@if %1==%j% echo 1

Kết quả 1 thành công, không có gì thất bại. Hoạt động cho số không quá, mặc dù không được yêu cầu bởi câu hỏi vì một số lý do.

JavaScript (ES7), 19 18 byte

Từ câu trả lời của tôi cho một câu hỏi liên quan .

Đầu ra falsecho số tam giác hoặc truekhông phải hình tam giác, được OP cho phép.

n=>(8*n+1)**.5%1>0

Thử nó

f=
n=>(8*n+1)**.5%1>0
oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

PHP, 30 byte

In 1 cho đúng và không có gì sai

<?=fmod(sqrt(8*$argn+1),2)==1;

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

fmod

PHP, 37 byte

In 1 cho đúng và không có gì sai

<?=($x=sqrt($q=2*$argn)^0)*$x+$x==$q;

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

Toán học, 28 byte

!Accumulate@Range@#~FreeQ~#&

Pari / GP , 18 byte

n->issquare(8*n+1)

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

Có một tích hợp để kiểm tra nếu một số là một số đa giác, nhưng nó dài hơn một byte.

Pari / GP , 19 byte

n->ispolygonal(n,3)

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

Excel, 31 22 byte

9 byte được lưu nhờ Octopus

Đầu ra TRUEcho số tam giác. Khác FALSE. Kiểm tra nếu 8*n+1là một hình vuông hoàn hảo.

=MOD(SQRT(8*B1+1),1)=0

Brachylog , 5 byte

≥ℕ⟦+?

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

Giải trình

≥ℕ⟦+?
≥ℕ     There is a number from 0 to {the input} inclusive
  ⟦    such that the range from 0 to that number
   +   has a sum
    ?  that equals the input

Fourier , 26 byte

I~X1(&N^*N/2{X}{1~O}N=X)Oo

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

Python - 52 byte

Lưu ý: Tôi biết rằng hai câu trả lời Python khác ngắn hơn nhiều, nhưng đây là cách học cũ, hơn là thuật toán thủ công

n=input();i=s=0
while s<n:s=(i*i+i)/2;i+=1
print s>n

APL (Dyalog) , 6 byte

⊢∊+\∘⍳

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

Giải trình

⊢∊+\∘⍳
      ⍳                 Creates a range from 1 to the right_argument
  +\                    Cumulative sum of this range; 1 1+2 1+2+3 .. 1+2+..+n. These are the triangular numbers
⊢∊                      Does the right argument belong to this list of integers in this cumulative sum

Đầu ra 0cho sai và 1đúng.

TI-CƠ BẢN, 10 7 byte

-3 cảm ơn @lirtosiast

:not(fPart(√(8Ans+1

Đưa đầu vào vào X. Kiểm tra nếu √(8X+1)là một số nguyên