Meydan okuma

Pozitif bir tamsayı verildiğinde, bunun üçgen bir sayı olup olmadığını belirleyin ve buna göre herhangi iki sabit, farklı değerden birini verin.

Tanım

Bir üçgen sayıda Bunlar ayrıca, formül ile ifade edilebilir 1'den başlayarak, birbirini takip eden pozitif tamsayı toplamı olarak ifade edilebilir bir sayıdır n(n + 1) / 2, nbir pozitif tamsayıdır.

Test durumları

Truthy:

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

Falsy:

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

kurallar

• Girişiniz bir işlev veya program olabilir.
• Girişin 10'un altındaki pozitif bir tamsayı olduğunu varsayabilirsiniz. ^6'nın .
• İki kategoriyi ayırt etmek için iki sabit, ayrı çıktı seçmelisiniz.

Bu kod golf , yani her dilde bayt cinsinden en kısa kod kazanır.

Haskell , 23 bayt

DÜZENLE:

• -1 bayt: @ xnor, a ile parantezlerden kurtuldu $.

Anonim bir işlev alan Intve dönen bir a Char.

Çıktı '1'üçgen sayılar ve '0'diğerleri içindir.

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

Çevrimiçi deneyin!

• Olarak kullanın ((!!)$show.(10^)=<<[0..]) 998991.

• 1, 10, 100, 1000, ... sayılarını üretir, bunları dizelere dönüştürür ve birleştirir. Sonra ortaya çıkan sonsuz dizeye endeksler

  "1101001000100001000001000000...

Python , 24 bayt

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

Çevrimiçi deneyin!

Diğerleri Falseiçin üçgen sayılar için çıktılar True. 8*n+1Mükemmel bir kare olup olmadığını kontrol eder . Python, ne kadar büyük olursa olsun, tam sayıdaki tam yüzer için mükemmel kareler alır, bu nedenle kayan nokta sorunları yoktur.

Jöle , 4 bayt

R+\ċ

Çevrimiçi deneyin!

Nasıl?

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

Retina , 10 bayt

(^1|1\1)+$

Giriş bir arada. Çıktı 0veya 1.

Çevrimiçi deneyin! (Kolaylık sağlamak için ondalık birime dönüşüm yapan bir test paketi olarak.)

açıklama

Bu ileri referanslardaki en temel alıştırmadır. Çoğu insan regex'deki geri referansları bilir; örneğin(.)\1 tekrarlanan bir karakterle eşleşmek için. Bununla birlikte, daha gelişmiş lezzetlerin bazıları, atıfta bulunduğu gruptan önce veya içinde geri dönüş kullanmanıza izin verir. Bu durumda, genellikle bir ileri referans denir. Referans tekrarlanırsa bu anlamlı olabilir. İlk yinelemede iyi tanımlanmamış olabilir, ancak sonraki yinelemelerde daha sonraki veya çevreleyen grup bir şey yakalamış ve yeniden kullanılabilir.

Bu en yaygın olarak, tekli dizgelerde yinelenen kalıpları uygulamak için kullanılır. Bu durumda, girişi ardışık tam sayıların toplamı olarak eşleştirmeye çalışırız:

(        # 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 bayt

( 8x + 1 ) kare sayı olup olmadığını kontrol eder .

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

Çevrimiçi deneyin!

Mathematica, 16 bayt

OddQ@Sqrt[1+8#]&

Temelde bir xnor'ın Python çözümü limanı . Aksi takdirde Trueüçgen sayılar için çıktılar False.

JavaScript (ES6), 30 27 bayt

Kamoroso94 sayesinde 2 bayt kaydedildi

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

Test durumları

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))

Özyinelemeli olmayan sürüm (ES7), 19 bayt

Adnan Limanı'nın cevabını .

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

CJam , 11 bayt

ri2*_mQ_)*=

Aksi takdirde 1üçgen için çıkışlar 0.

Çevrimiçi deneyin!

açıklama

Girişi düşünün 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

Beyin Flak , 40 bayt

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

Buğday Sihirbazı ve ben bir düello vardı bu . Çözümlerimizi göndermeye karar verdiğimizde 42 bayta bağlandık, ancak çözümünün 2 baytlık bir golfünü buldum. Bunun kravat kırıcı olarak sayılmasına karar verdik (çözümüm aşağıdadır).

Çevrimiçi deneyin!

Açıklama:

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

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

Tam bir açıklama için lütfen Buğday Sihirbazı'nın cevabına bakınız .

Brain-Flak , 42 bayt

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

0\nHakikat için çıktılar (değişmez yeni satır) ve sahte için boş dize.

Buradaki fikir, girişe kadar önce 1 sonra 2 sonra 3 çıkartmaktır. 0'a basarsanız, bunun üçgen bir sayı olduğunu bilirsiniz, böylece burada durabilirsiniz.

Çevrimiçi deneyin! (truthy)
Çevrimiçi deneyin! (falsy)

# 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
}

İşte ilginç bulduğum 46 baytlık bir çözüm.

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

0\nGerçeklik için çıktılar (değişmez yeni satır), sahte için boş dize.

Buradaki fikir, girişten ardışık sayılarla her defasında 1 geri saymaktır. Örneğininput - (1) - (1,1) - (1,1,1) . Her çıkarttığımızda, eğer henüz 0'da değilsek, yığında ekstra bir değer bırakırız. Bu şekilde, eğer 0'daysak ve pop açıldığında hala çıkarılıyorsa, yığındaki son değeri kaldırırız. Girdi üçgen bir sayıysa, tam olarak 0'da biteceğiz ve 0'ı açmayacağız.

Çevrimiçi deneyin! truthy
Çevrimiçi deneyin! falsy

# 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.
}

Jöle , 5 bayt

×8‘Ʋ

Çevrimiçi deneyin!

Arka fon

Let n girilebilir. Eğer n ise k ^inci üçgen sayı, elimizdeki

bu, eğer sadece 1 + 8n tek, mükemmel bir kare ise doğal bir çözüm olacaktır . Açıkça, 1 + 8n paritesinin kontrol edilmesi gerekli değildir.

Nasıl çalışır

×8‘Ʋ  Main link. Argument: n

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

PowerShell , 31 30 bayt

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

Çevrimiçi deneyin!

Güzel ve yavaş kaba kuvvet yöntemi. 1 ile 10 ⁶ arasında her toplamdan bir dizi yapın ve argümanın orada olup olmadığını görün.

Brain-Flak , 42 bayt

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

Çevrimiçi deneyin!

açıklama

Bu programın amacı, iki yığında bir durum yaratmak ve her iki yığında da sürekli bir işlem yapmak ve bunlardan biri sıfır olunca, hangi yığında olduğumuza bağlı olarak çıktı verebiliyoruz. Bu, bir sayının işaretini belirleyen programlara benzer. Bu programlar nbir yığına koymak ve-n ekler ve yığınlardan biri sıfır olana kadar yığınları değiştirir. İlk etapta sayı negatifse, ilk yığın sıfıra varacaktır, sayı pozitif ise diğer yığın sıfıra varacaktır.

Burada, girişten ardışık sayıları çıkaran ve yalnızca birini çıkaran iki yığın oluştururuz. Ardışık sayıları çıkaran sayı, yalnızca sayı üçgense sona erer, (aksi takdirde sadece sıfıra geçecek ve negatiflere devam edecektir). Diğeri her zaman pozitif bir sayı için sonlanır, ancak her zaman ilkinden daha yavaş olur, böylece üçgen olmayan sayılar o yığında sona erer.

Öyleyse yığınları nasıl ayarlıyoruz ki aynı işlem birinden ardışık sayıları ve diğerini de çıkarıyor? Her bir yığında girdiler üsttedir, böylece kontrol edilebilir, altında fark var ve altında fark var. Çalıştığımız her seferde "farkın farkı" nı normal "fark" a ekliyoruz ve bunu girdiden çıkartıyoruz. Üçgenliği kontrol eden yığın için, çifte farkımızı, 1her çalıştırmamızda ardışık tamsayıları alacağımız şekilde, diğer yığın için 0ise farkı asla değiştirmeyecek şekilde ayarladık , yani her zaman 1 kalacaktır. yığın başlangıçta nasıl kurulur n, girdi nerededir:

-n  -n
 0   1
 1   0

Nihayet sonlandırdığımızda, bu yığları hangi yığında olduğumuzu kontrol etmek için kullanabiliriz, ilk iki değeri alırız ve 1üçgen bir sayı ve 0üçgen olmayan bir sayı alırız .

Açıklamalı kod

(([{}](<((())<>)>))<>) 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

İşte benim de sevdiğim 50 baytlık bir çözüm.

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

Çevrimiçi deneyin!

Cubix , 23 24 25 bayt

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

Truthy için 0 ve falsey için 0 değil . Kuvvetleri, sayacı artırarak, toplam tutara ekleyerek ve girdiyle karşılaştırarak kuvvetlendirir. Şimdi denemek ve 2x2x2 küp üzerinde sığdırmak için. Yaptı!

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

Çevrimiçi deneyin!

• / Yüzleşmeyi reddetmek.
• I10\ tamsayı girişini al, 1 (sayıcı), 0 (toplam) bas ve yansıt
• +s;p-döngü gövdesi. Toplamı ve sayacı ekle, önceki toplamı düşür, girişi arttır ve çıkar
• ? Çıkarma sonucunu test edin
  • Dümdüz ileride devam eden 0 sonuç \.uO@için alt yüze, operasyon yok, U dönüşü, çıkış ve durma yansımış.
  • Olumlu sonuç için alt yüze sağa dönün ve @durun
  • Negatif sonuç için sola ;qWs)/subırakma çıkarma, girişi aşağıya koyma, sola kaydırma, sayaç ve toplamı değiştirme, artış sayacı, yansıtma, toplamı ve sayacı değiştirme, ana döngü gövdesine U dönüşü.

05AB1E , 7 6 bayt

EDIT : @Dennis sayesinde: Bir bayt kaydedildi, çünkü artış işlecini unuttum

8*>t.ï

Çevrimiçi deneyin!

nsqrt(8n + 1)bir tamsayı ise üçgen

Nasıl çalışır

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

Perl 6 , 17 bayt

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

Sadece $_, fonksiyona yapılan girişin, üçgen ekleme azaltma öğelerinin herhangi birine eşit olup olmadığını kontrol eder (1, 1+2, ..., 1+2+...+$_).

Alice , 38 22 bayt

Martin ve Leo sayesinde çok sayıda bayt kurtarıldı

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

Sonunda yeni bir satır var. Aksi takdirde 1üçgen için çıkışlar 0.

Çevrimiçi deneyin!

açıklama

Bu benim CJam cevabım ile aynı yaklaşımı kullanır , sadece sakar. Doğrusallaştırılmış biçimde, program olur

i2*.2RE.h*-no@

nerede iveo sıra modunda aslında.

21Bir örnek olarak girişi düşünün .

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 bayt

@Luke ve @ETHproductions sayesinde 3 bayt kurtarıldı

*8Ä ¬v1

Çevrimiçi deneyin!

Açıklama:

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

õ å+ øU

Açıklama:

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

Çevrimiçi deneyin!

R , 23 19 bayt

Diğer cevaplar ile benzer bir yaklaşım. 8x+1Mükemmel bir kare olup olmadığını kontrol eder .
-4 bayt Giuseppe ve MickyT teşekkürler.

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

Çevrimiçi deneyin!

MATL , 5 bayt

t:Ysm

Çevrimiçi deneyin!

Açıklama:

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

Batch, 72 bytes

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

Outputs 1 on success, nothing on failure. Works for zero too, although not requested by the question for some reason.

JavaScript (ES7), 19 18 bytes

From my answer to a related question.

Outputs false for triangular numbers or true for non-triangular, as permitted by the OP.

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

Try It

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

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

PHP, 30 Bytes

Prints 1 for true and nothing for false

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

Try it online!

fmod

PHP, 37 Bytes

Prints 1 for true and nothing for false

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

Try it online!

Mathematica, 28 bytes

!Accumulate@Range@#~FreeQ~#&

Pari/GP, 18 bytes

n->issquare(8*n+1)

Try it online!

There is a built-in to test if a number is a polygonal number, but it is one byte longer.

Pari/GP, 19 bytes

n->ispolygonal(n,3)

Try it online!

Excel, 31 22 bytes

9 bytes saved thanks to Octopus

Outputs TRUE for triangular numbers. Else FALSE. Checks if 8*n+1 is a perfect square.

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

Brachylog, 5 bytes

≥ℕ⟦+?

Try it online!

Explanation

≥ℕ⟦+?
≥ℕ     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 bytes

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

Try it online!

Python - 52 bytes

Note: I know that the other two Python answers are much shorter, but this is the old-school way, more of a by-hand algorithm

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

APL (Dyalog), 6 bytes

⊢∊+\∘⍳

Try it online!

Explanation

⊢∊+\∘⍳
      ⍳                 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

Outputs 0 for false and 1 for true.

TI-BASIC, 10 7 bytes

-3 thanks to @lirtosiast

:not(fPart(√(8Ans+1

Takes input on X. Checks if √(8X+1) is a whole number