You are given four numbers. The first three are \$a\$, \$b\$, and \$c\$ respectively, for the sequence:


You may take input of these four numbers in any way. The output should be one of two distinct outputs mentioned in your answer, one means that the fourth number is a term in the sequence (the above equation has at least one solution for \$n\$ which is an integer when \$a\$, \$b\$, \$c\$ and \$T_n\$ are substituted for the given values), the other means the opposite.

This is code golf, so the shortest answer in bytes wins. Your program should work for any input of \$a, b, c, T_n\$ where the numbers are negative or positive (or 0), decimal or integer. To avoid problems but keep some complexity, non-integers will always just end in \$.5\$. Standard loop-holes disallowed.

Test cases

a   |b   |c   |T_n |Y/N
1   |1   |1   |1   |Y     #n=0
2   |3   |5   |2   |N
0.5 |1   |-2  |-0.5|Y     #n=1
0.5 |1   |-2  |15.5|Y     #n=5
0.5 |1   |-2  |3   |N     
-3.5|2   |-6  |-934|Y     #n=-16
0   |1   |4   |7   |Y     #n=3
0   |3   |-1  |7   |N
0   |0   |0   |1   |N
0   |0   |6   |6   |Y     #n=<anything>
4   |8   |5   |2   |N

5 Answers 5


JavaScript (ES7), 70 bytes

Returns a Boolean value.


Try it online!


For the sake of clarity, we define \$d = T_n-c\$. (The same variable \$t\$ is re-used to store this result in the JS code.)

Case \$a\neq0\$

The equation really is quadratic:

$$T_n=an^2+bn+c\\ an^2+bn-d=0$$

With \$a'=2a\$, the discriminant is:


and the roots are:

$$n_0=\frac{-b-\sqrt{\Delta}}{a'}\\ n_1=\frac{-b+\sqrt{\Delta}}{a'}$$

The equation admits an integer root if \$\sqrt{\Delta}\$ is an integer and either:

$$\begin{align}&-b-\sqrt{\Delta}\equiv 0\pmod{a'}\\ \text{ or }&-b+\sqrt{\Delta}\equiv 0\pmod{a'}\end{align}$$

Case \$a=0, b\neq0\$

The equation is linear:

$$T_n=bn+c\\ bn=d\\ n=\frac{d}{b}$$

It admits an integer root if \$d\equiv0\pmod b\$.

Case \$a=0, b=0\$

The equation is not depending on \$n\$ anymore:

$$T_n=c\\ d=0$$


Jelly,  11  10 bytes


A monadic Link which accepts a list of lists* [[c, b, a], [T_n]] and yields 0 if T_n is a valid solution or 1 if not.

* admittedly taking a little liberty with "You may take input of these four numbers in any way".

Try it online! Or see a test-suite.


_/Ær1Ẹ?%1Ạ - Link: list of lists of integers, [[c, b, a], [T_n]]
 /         - reduce by:
_          -   subtraction                    [c-T_n, b, a]
      ?    - if...
     Ẹ     - ...condition: any?
  Ær       - ...then: roots of polynomial     i.e. roots of a²x+bx+(c-T_n)=0
    1      - ...else: literal 1
       %1  - modulo 1 (vectorises)            i.e. for each: keep any fractional part
           -                                       note: (a+bi)%1 yields nan which is truthy
         Ạ - all?                             i.e. all had fractional parts?
           -                                       note: all([]) yields 1

If we could yield non-distinct results then _/Ær1Ẹ?ḞƑƇ would also work for 10 (it yields 1 when all values are solutions, otherwise a list of the distinct solutions and hence always an empty list when no solutions - this would also meet the standard Truthy vs Falsey definition)

  • 2
    \$\begingroup\$ That input is perfectly fine. \$\endgroup\$
    – Miriam
    Commented Apr 3, 2019 at 18:21

05AB1E, 35 bytes


Port of @Arnauld's JavaScript answer, so make sure to upvote him!

Takes the input in the format \$[t,c], a, b\$.

Try it online


Æ                         # Reduce the (implicit) input-list by subtraction (`t-c`)
 ©                        # Store this value in the register (without popping)
  ²Āi                     # If the second input `a` is not 0:
     ²4P                  #  Calculate `(t-c)*a*4`
        ³n+               #  Add the third input `b` squared to it: `(t-c)*a*4+b*b`
           t              #  Take the square-root of that
                          #  (NOTE: 05AB1E and JS behave differently for square-roots of
                          #   negative integers; JS produces NaN, whereas 05AB1E leaves the
                          #   integer unchanged, which is why we have the `di...}` here)
            Ð             #  Triplicate this square
             di           #  If the square is non-negative (>= 0):
               (‚         #   Pair it with its negative
                 ³-       #   Subtract the third input `b` from each
                   Ä      #   Take the absolute value of both
                    ²·Ä%  #   Modulo the absolute value of `a` doubled
                          #   (NOTE: 05AB1E and JS behave differently for negative modulos,
                          #    which is why we have the two `Ä` here)
                        P #   Then multiply both by taking the product
              }           #  And close the inner if-statement
    ë                     # Else (`a` is 0):
     ®                    #  Push the `t-c` from the register
      ³Āi                 #  If the third input `b` is not 0:
         ³%               #   Take modulo `b`
    ]                     # Close both if-else statements
     _                    # And check if the result is 0
                          # (which is output implicitly)
  • \$\begingroup\$ Would Ų save some bytes? (Probably not since we later need to compute the square root anyway.) \$\endgroup\$
    – Arnauld
    Commented Apr 4, 2019 at 10:37
  • \$\begingroup\$ @Arnauld Unfortunately not for three reasons: 1. Ų with negative values somehow gives the value itself instead of 0.. 2. Ų with decimal values (even with .0) gives 0 instead of 1 whether they're a square or not (this is a bug which I will report to Adnan). 3. Even if both would have worked and -4.0 would result in 0 instead of -4.0 and 4.0 would result in 1 instead of 0, it would still be +2 bytes since we need the square-root and the triplicate would be separated duplicates: tÐdi vs DŲitD; or currently DÄïŲitD to fix the other two mentioned issues. \$\endgroup\$ Commented Apr 4, 2019 at 11:58
  • 1
    \$\begingroup\$ Besides, the results of Ų on negative inputs are inconsistent. \$\endgroup\$
    – Arnauld
    Commented Apr 4, 2019 at 12:30
  • \$\begingroup\$ @Arnauld Wth.. that's indeed pretty weird. And the legacy version even gives a different, just as weird result.. :S I've reported the bugs, including your test TIO to Adnan in the 05AB1E chat. \$\endgroup\$ Commented Apr 4, 2019 at 12:31

Wolfram Language (Mathematica), 38 bytes


Try it online!


Jelly, 15 bytes


Try it online!

Built-in helps here but doesn’t handle a=b=0 so this is handled specially.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.