Herausforderung

Bestimmen Sie bei einer positiven Ganzzahl, ob es sich um eine Dreieckszahl handelt, und geben Sie dementsprechend einen von zwei konstanten, unterschiedlichen Werten aus.

Definition

Eine Dreieckszahl ist eine Zahl, die als Summe aufeinanderfolgender positiver Ganzzahlen ab 1 ausgedrückt werden kann. Sie kann auch mit der Formel ausgedrückt werden n(n + 1) / 2, bei der nes sich um eine positive Ganzzahl handelt.

Testfälle

Wahrheit:

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

Falsch:

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

Regeln

• Ihr Eintrag kann eine Funktion oder ein Programm sein.
• Sie können annehmen, dass die Eingabe eine positive ganze Zahl unter 10 ^{6 ist} .
• Sie müssen zwei konstante, unterschiedliche Ausgaben auswählen, um die beiden Kategorien zu unterscheiden.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache.

Haskell , 23 Bytes

BEARBEITEN:

• -1 Byte: @xnor hat Klammern mit a entfernt $.

Eine anonyme Funktion, die eine nimmt Intund eine zurückgibt Char.

Die Ausgabe erfolgt '1'für Dreieckszahlen und '0'für andere.

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

Probieren Sie es online!

• Verwenden Sie als ((!!)$show.(10^)=<<[0..]) 998991.

• Erzeugt die Zahlen 1, 10, 100, 1000, ..., konvertiert diese in Zeichenfolgen und verkettet sie. Indiziert dann in die resultierende unendliche Zeichenfolge

  "1101001000100001000001000000...

Python , 24 Bytes

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

Probieren Sie es online!

Ausgänge Falsefür Dreieckszahlen, Truefür den Rest. Prüft, ob 8*n+1es sich um ein perfektes Quadrat handelt. Python verwendet perfekte Quadrate, um ganzzahlige Gleitkommazahlen zu erhalten, egal wie groß sie sind. Es gibt also keine Gleitkommazahlen.

Gelee , 4 Bytes

R+\ċ

Probieren Sie es online!

Wie?

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 Bytes

(^1|1\1)+$

Die Eingabe ist unär. Ausgang ist 0oder 1.

Probieren Sie es online! (Als Testsuite, die der Einfachheit halber Dezimal-Unär-Konvertierungen durchführt.)

Erläuterung

Dies ist die grundlegendste Übung bei Vorwärtsreferenzen. Die meisten Leute sind mit Rückreferenzen in Regex vertraut, zB (.)\1um einem wiederholten Zeichen zu entsprechen. In einigen fortgeschrittenen Varianten können Sie jedoch einen Rückverweis vor oder innerhalb der Gruppe verwenden, auf die er sich bezieht. In diesem Fall spricht man normalerweise von einer Vorwärtsreferenz. Dies kann sinnvoll sein, wenn der Verweis wiederholt wird. Möglicherweise ist es bei der ersten Iteration nicht genau definiert, aber bei nachfolgenden Iterationen hat die spätere oder umgebende Gruppe etwas erfasst und kann wiederverwendet werden.

Dies wird am häufigsten verwendet, um wiederkehrende Muster für unäre Zeichenfolgen zu implementieren. In diesem Fall versuchen wir, die Eingabe als Summe aufeinanderfolgender Ganzzahlen abzugleichen:

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

Überprüft, ob ( 8x + 1 ) eine quadratische Zahl ist.

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

Probieren Sie es online!

Mathematica, 16 Bytes

OddQ@Sqrt[1+8#]&

Im Wesentlichen eine Portierung der Python-Lösung von xnor . Ansonsten Ausgabe Truefür Dreieckszahlen False.

JavaScript (ES6), 30 27 Bytes

2 Bytes dank kamoroso94 gespeichert

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

Testfälle

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

Nicht rekursive Version (ES7), 19 Byte

Antwort von Port of Adnan .

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

CJam , 11 Bytes

ri2*_mQ_)*=

Ausgänge 1für Dreieck, 0sonst.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe 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 Bytes

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

Wheat Wizard und ich hatten ein Duell um diese Frage. Als wir beschlossen, unsere Lösungen zu veröffentlichen, waren wir mit 42 Bytes gebunden, aber ich fand einen 2-Byte-Golf seiner Lösung. Wir haben uns entschieden, dass dies als Gleichstand gelten würde (meine Lösung ist unten).

Probieren Sie es online!

Erläuterung:

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

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

Eine vollständige Erklärung finden Sie in der Antwort von Wheat Wizard .

Brain-Flak , 42 Bytes

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

Ausgaben 0\n(Literal Newline) für Truthy und die leere Zeichenfolge für Falsy.

Die Idee ist, 1, 2 und 3 bis zum Eingang zu subtrahieren. Wenn Sie 0 drücken, wissen Sie, dass dies eine dreieckige Zahl ist, sodass Sie dort anhalten können.

Probieren Sie es online! (ehrlich)
Probieren Sie es online! (falsch)

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

Hier ist eine 46-Byte-Lösung, die ich interessant fand.

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

Ausgaben 0\n(Literal Newline) für Truthy, die leere Zeichenfolge für Falsy.

Die Idee ist, von der Eingabe durch aufeinanderfolgende Zahlen jeweils 1 abwärts zu zählen. Eg input - (1) - (1,1) - (1,1,1). Jedes Mal, wenn wir subtrahieren, wenn wir noch nicht bei 0 sind, belassen wir einen zusätzlichen Wert auf dem Stapel. Auf diese Weise entfernen wir den letzten Wert auf dem Stapel, wenn wir bei 0 sind und immer noch subtrahieren, wenn wir Pop ausführen. Wenn die Eingabe eine Dreieckszahl war, werden wir genau bei 0 enden und die 0 nicht einfügen.

Probieren Sie es online! truthy
Online ausprobieren! falsch

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

Gelee , 5 Bytes

×8‘Ʋ

Probieren Sie es online!

Hintergrund

Sei n die Eingabe. Wenn n die k- ^te Dreieckszahl ist, haben wir

Das heißt, es wird eine natürliche Lösung geben, wenn 1 + 8n ein ungerades, perfektes Quadrat ist. Es ist offensichtlich nicht erforderlich , die Parität von 1 + 8n zu überprüfen .

Wie es funktioniert

×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+=$_)})

Probieren Sie es online!

Nette und langsame Brute-Force-Methode. Machen Sie aus jeder Summe von 1 bis 10 ⁶ ein Array und prüfen Sie, ob das Argument darin enthalten ist.

Brain-Flak , 42 Bytes

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

Probieren Sie es online!

Erläuterung

Das Ziel dieses Programms ist es, einen Status für zwei Stapel zu erstellen und eine konstante Operation für beide Stapel durchzuführen, bis einer von ihnen Null ist. Abhängig davon, auf welchem ​​Stapel wir uns befinden, können wir dann ausgeben. Dies ähnelt Programmen, die das Vorzeichen einer Zahl bestimmen. Diese Programme legen neinen Stapel -nauf den anderen und fügen einen hinzu und wechseln die Stapel, bis einer der Stapel Null ist. Wenn die Zahl an erster Stelle negativ war, schlägt der erste Stapel auf Null, wenn die Zahl positiv war, schlägt der andere Stapel auf Null.

Hier erstellen wir zwei Stapel, von denen einer fortlaufende Zahlen von der Eingabe abzieht, und einer, von dem nur einer abgezogen wird. Diejenige, die fortlaufende Zahlen subtrahiert, endet nur, wenn die Zahl dreieckig ist (andernfalls passiert sie nur Null und geht weiter ins Negative). Die andere endet immer für eine positive Zahl, jedoch immer langsamer als die erste, sodass nicht dreieckige Zahlen auf diesem Stapel enden.

Wie richten wir also Stapel so ein, dass dieselbe Operation aufeinanderfolgende Zahlen voneinander subtrahiert und aufeinanderfolgende subtrahiert? Auf jedem Stapel haben wir die Eingabe oben, damit in überprüft werden kann, unten haben wir die Differenz und unten haben wir die Differenz der Differenz. Bei jedem Durchlauf addieren wir die "Differenz der Differenz" zur regulären "Differenz" und subtrahieren diese von der Eingabe. Für den Stapel, der auf Dreieckigkeit prüft, setzen wir unseren doppelten Unterschied 1so, dass wir bei jeder Ausführung aufeinanderfolgende ganze Zahlen erhalten, für den anderen Stapel setzen wir ihn 0so, dass wir den Unterschied nie ändern, das heißt, er bleibt immer 1. Hier ist wie der Stack am Anfang aufgebaut ist, wo nist die Eingabe:

-n  -n
 0   1
 1   0

Wenn wir endlich fertig sind, können wir diese Unterschiede nutzen, um zu überprüfen, auf welchem ​​Stapel wir uns befinden. Wir platzieren die ersten beiden Werte und erhalten sie 1für eine dreieckige und 0eine nicht dreieckige Zahl.

Kommentierter Code

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

Hier ist eine 50-Byte-Lösung, die ich auch mag.

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

Probieren Sie es online!

Cubix , 23 24 25 Bytes

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

0 für wahr und nichts 0 für falsch. Brutes Forces durch Inkrementieren des Zählers, Addieren der kumulativen Summe und Vergleichen mit der Eingabe. Versuchen Sie nun, es auf einen 2x2x2-Würfel zu setzen. Geschafft!

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

Probieren Sie es online!

• / Reflektiere zu Gesicht.
• I10\ Holen Sie sich eine Ganzzahl-Eingabe, drücken Sie 1 (Zähler), drücken Sie 0 (Summe) und reflektieren Sie
• +s;p-Schleifenkörper. Addiere Summe und Zähler, lösche vorherige Summe, erhöhe Eingabe und subtrahiere
• ? Testen Sie das Ergebnis der Subtraktion
  • Für ein Ergebnis von 0, das geradeaus weitergeht, \.uO@reflektieren Sie auf die Unterseite, No-Op, U-Turn, Output und Stop.
  • Biegen Sie für ein positives Ergebnis rechts auf die Unterseite ab und @halten Sie an
  • Für ein negatives Ergebnis die ;qWs)/suDrop-Subtraktion nach links drehen , die Eingabe nach unten setzen, nach links verschieben, Zähler und Summe tauschen, Zähler inkrementieren, reflektieren, Summe und Zähler tauschen, auf den Hauptschleifenkörper drehen.

05AB1E , 7 6 Bytes

EDIT : Danke an @Dennis: Ein Byte gespeichert, weil ich den Inkrementoperator vergessen habe

8*>t.ï

Probieren Sie es online!

nist dreieckig, wenn sqrt(8n + 1)es sich um eine ganze Zahl handelt

Wie es funktioniert

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

Perl 6 , 17 Bytes

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

Überprüft nur, ob $_die Eingabe für die Funktion mit einem der Elemente der dreieckigen Additionsreduktion übereinstimmt (1, 1+2, ..., 1+2+...+$_).

Alice , 38 22 Bytes

Dank Martin und Leo konnten viele Bytes eingespart werden

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

Es gibt einen nachgestellten Zeilenumbruch. Ausgänge 1für Dreieck, 0sonst.

Probieren Sie es online!

Erläuterung

Dies verwendet den gleichen Ansatz wie meine CJam-Antwort , nur ungeschickter. In linearisierter Form wird das Programm

i2*.2RE.h*-no@

wo die iund oeigentlich im ordinalen Modus sind.

Betrachten Sie die Eingabe 21als Beispiel.

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 Bytes

3 Bytes gespart dank @Luke und @ETHproductions

*8Ä ¬v1

Probieren Sie es online!

Erläuterung:

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

õ å+ øU

Erläuterung:

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

Probieren Sie es online!

R , 23 19 Bytes

Ähnliches Vorgehen wie bei anderen Antworten. Prüft, ob 8x+1es sich um ein perfektes Quadrat handelt.
-4 bytes danke Giuseppe und MickyT.

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

Probieren Sie es online!

MATL , 5 Bytes

t:Ysm

Probieren Sie es online!

Erläuterung:

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

Gibt 1 bei Erfolg aus, nichts bei Misserfolg. Funktioniert auch für Null, obwohl dies aus irgendeinem Grund von der Frage nicht verlangt wird.

JavaScript (ES7), 19 bis 18 Byte

Von meiner Antwort auf eine verwandte Frage .

Ausgänge falsefür Dreieckszahlen oder truefür nicht-Dreieckszahlen, wie vom OP zugelassen.

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

Versuch es

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

Gibt 1 für wahr und nichts für falsch aus

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

Probieren Sie es online!

fmod

PHP, 37 Bytes

Gibt 1 für wahr und nichts für falsch aus

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

Probieren Sie es online!

Mathematica, 28 Bytes

!Accumulate@Range@#~FreeQ~#&

Pari / GP , 18 Bytes

n->issquare(8*n+1)

Probieren Sie es online!

Es ist eine integrierte Funktion zum Testen, ob eine Zahl eine polygonale Zahl ist, die jedoch ein Byte länger ist.

Pari / GP , 19 Bytes

n->ispolygonal(n,3)

Probieren Sie es online!

Excel, 31 22 Bytes

Dank Octopus 9 Bytes gespart

Ausgänge TRUEfür Dreieckszahlen. Else FALSE. Prüft, ob 8*n+1es sich um ein perfektes Quadrat handelt.

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

Brachylog , 5 Bytes

≥ℕ⟦+?

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Python - 52 Bytes

Hinweis: Ich weiß, dass die anderen beiden Python-Antworten viel kürzer sind, aber dies ist die alte Art und Weise, eher ein manueller Algorithmus

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

APL (Dyalog) , 6 Bytes

⊢∊+\∘⍳

Probieren Sie es online!

Erläuterung

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

Ausgaben 0für false und 1für true.

TI-BASIC, 10 7 Bytes

-3 danke an @lirtosiast

:not(fPart(√(8Ans+1

Übernimmt die Eingabe X. Prüft, ob √(8X+1)eine ganze Zahl ist