[Question]
  [
### Your task
Given a integer input, \$ n \$ (such that \$ n > 1 \$), decide whether it can be written as the sum of (at least 2) consecutive square numbers.
### Test cases
**Truthy:**
```
Input  Explanation
5      1 + 4
13     4 + 9
14     1 + 4 + 9
25     9 + 16
29     4 + 9 + 16
30     1 + 4 + 9 + 16
41     16 + 25
50     9 + 16 + 25
```
**Falsy:**
(Any number from 2 to 50 that's not in the truthy test cases)
### Clarifications and notes
* For reference, [here](https://ato.pxeger.com/run?1=TZBdTsQgFIXfu4rzVuiPsU2Mk8a6kaYP2FKlQ2GkkIxr8aUx0T3NbgQH07kvwM35zrmXz5_Th33Tart8re-OGb6ihWTLy8igGnTHLKsxaYMjhIJh6pWTqvB3S1SW3T3QvKJ9Mmi18uEGlV7S1p6X3dzMuej_PObdQ3JFJC1FwJGDCDzh2gNTI6IhCT5eAg93Pf12dioPl2XkE1YtnRVakTNtEvgKAUMI-GfjPl4QFaGEJ91CBoq2xXnvhzLcOuP55OaRpjH0MfiLfYG6QHVfReeTCR8iCqTlc1rsswkaZ9626_kL) is an ungolfed Python program which will get all the truthy values up to 100.
* This is [OEIS A174069](https://oeis.org/A174069)
* [Default [decision-problem] rules](https://codegolf.meta.stackexchange.com/questions/19202/default-policy-for-output-in-decision-problems) apply
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins!
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
Ẇḋ`ṫċ
```
[Try it online!](https://tio.run/##ASUA2v9qZWxsef//4bqG4biLYOG5q8SL/@G4isOH4oKsVOKAmP//MTAw "Jelly – Try It Online")
```
Ẇḋ`ṫċ     – link, we call the argument n
Ẇ         – all contiguous sublists of [1, ..., n]
 ḋ        – dot product (vectorized) with...
  `       ... itself (` makes a monad from a dyad by repeating the argument)
   ṫ      – discard the first n-1 (for n>1, n^2 ≠ n, so it's ok)
    ċ     – count the occurences of n in this list
```
[Answer]
# [R](https://www.r-project.org), ~~57~~ ~~52~~ ~~49~~ 48 bytes
```
\(n)n%in%apply(array(1:n,1:0+n)^2,2,cumsum)[-1,]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3DWI08jTzVDPzVBMLCnIqNRKLihIrNQyt8nQMrQy08zTjjHSMdJJLc4tLczWjdQ11YiH69qdpmGpypWmYaHKVZ2QmZ2gUQ7QbWpka6KRpakJULVgAoQE)
### Explanation outline:
1. Construct a matrix with `n+1` rows: filling up columns with `1:n` (with recycling). For `n=5`:
```
1    2    3    4    5
2    3    4    5    1
3    4    5    1    2
4    5    1    2    3
5    1    2    3    4
1    2    3    4    5
```
2. Square values in the matrix.
3. Take cumulative sum of the columns. We don't care about the additional values in the bottom-right triangle of the matrix, as those are bigger than `n^2` (which is bigger than `n`).
```
 1    4    9   16   25
 5   13   25   41   26
14   29   50   42   30
30   54   51   46   39
55   55   55   55   55
56   59   64   71   80
```
4. Discard the first row, as it contains squares (not constructed as sums of squares).
5. Check if `n` is in the matrix.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 7 bytes
```
ÞS~Ḣ²Ṡc
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLDnlN+4biiwrLhuaBjIiwiIiwiMTQiXQ==)
**How it works**
```
ÞS~Ḣ²Ṡc
ÞS       Sublists of range 1-n
  ~Ḣ     Keep lists with length >= 2
    ²Ṡ   Square and sum each sublist
      c  Does it contain n?
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-1 thanks to Unrelated String (square after getting sublists of `[1..n]` avoiding `€`).
```
Ẇ²ḊƇ§ċ
```
A monadic Link that accepts an integer and yields the count of ways it is partitionable into consecutive (positive) squares (`0` is falsey while non-zero integers are truthy).
**[Try it online!](https://tio.run/##ARsA5P9qZWxsef//4bqGwrLhuIrGh8KnxIv///8zNjU "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##ASAA3/9qZWxsef//4bqGwrLhuIrGh8KnxIv/w4figqxU//81MA "Jelly – Try It Online").
### How?
```
Ẇ²ḊƇ§ċ - Link: integer, n
Ẇ      - all contiguous sublists of [1..n]
 ²     - square (vectorises)
   Ƈ   - filter keep those for which:
  Ḋ    -   dequeue (i.e. remove the singleton lists)
    §  - sums
     ċ - count occurrence of (n)
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 58 bytes
```
n=>(g=i=>(s+=++i*i)-n?s>n?q<n&&g(++q,s=q*q):g(i):1)(s=q=1)
```
[Try it online!](https://tio.run/##FYzBDoIwEAXvfkVPZJeKsQcvlIVvIUibZ8jWUuPv13qZZOYwr/W7lu3E@zNoeu41SFWZKQoaixVr0YMHXcqsS5606yJZm69Fcp95jAQeHVNTcVz9JaSTAHHeANPj7k0bgA0ChdaZzZa0pGO/HSn@g68/ "JavaScript (Node.js) – Try It Online")
By definition
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
§õ²ãx aU
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=p/Wy43ggYVU&input=NTA)
```
§õ²ãx aU     :Implicit input of integer U
§            :Less than or equal to
 õ           :  Range [1,U]
  ²          :  Square each
   ã         :  Sub arrays
    x        :  Reduced by addition
      aU     :  Last 0-based index of U
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~22~~ 21 bytes
```
{|//x=1_+\|+':3+\/=x}
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs6qu0devsDWM146p0Va3MtaO0betqOXi0lcoz0gtSlVIyU8tVkhTKEotKS3KUzBUyMxTiDbSUTA0MNC05zLSVktTN4pXBPIAGIYUCw==)
**Comments**:
```
                 =x   / Generate identity matrix of size x
             3+\/     / Three times cumulative sum;
                      / This puts triangular numbers on the columns, starting with 1 at the diagonal
          +':         / Sum adjacent values; This gives square numbers
         |            / Reverse the matrix
       +\             / Cumulative sums; Now matrix has all sums of ranges of sqaures
     1_               / Remove first row; This correspond to the sums of a single square
|//x=                 / Is any of the values equal to x?
```
[Try it](https://ngn.codeberg.page/k#eJxLs6qu0devsFWIMYxXiNGOUYipAVLqVgoxxtox+goxthW1XFxpDqYA5zcKvA==) with output of intermediate values.
[Answer]
# [Python](https://www.python.org), 71 bytes
```
lambda n,k=0:(z:={k:=k+j*j for j in range(n)if j*j<n})&{l+n for l in z}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY33XMSc5NSEhXydLJtDaw0qqxsq7OtbLO1s7SyFNLyixSyFDLzFIoS89JTNfI0M9MUgOI2ebWaatU52nlgBTkgBVW1UONUQEKZCD2GOqaGmlZcnAVFmXklGpk6aRqZmpoQtQsWQGgA)
# [Python](https://www.python.org) NumPy, 68 bytes
```
lambda n:{*(z:=cumsum(x:=r_[:n]**2)[x<n])}&{*z+n}
from numpy import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3XXISc5NSEhXyrKq1NKqsbJNLc4tLczUqrGyL4qOt8mK1tIw0oyts8mI1a9Wqtaq082q50orycxXySnMLKhUycwvyi0q0oGappOUXKWQqZOYpFCXmpadqGOqYGmpacXEWFGXmlWhk6qRpZGpqQtQuWAChAQ)
Returns the empty set for False and a nonempty set for True.
### How?
Compares (i.e. intersects) the sets {0,1,1+4,1+4+9,...,1+4+...+j^2} and {n,n+1,n+1+4,n+1+4+9,...,n+1+4+...+j^2} where j is the largest number such that j^2<n.
[Answer]
# [Python](https://www.python.org), 73 bytes
```
lambda n:n in[-~(r:=i//n+1)*(r*(r/3+i%n+1/6)+i%n*i%n)for i in range(n*n)]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3PXMSc5NSEhXyrPIUMvOides0iqxsM_X187QNNbU0ioBI31g7UxXI1TfTBDG0gFgzLb9IIROoXqEoMS89VSNPK08zFmqgCpqckY6poaYVF2dBUWZeiUamTppGpqYmRO2CBRAaAA)
Formula for \$\sum\_{i=x}^{x+r}i^2\$ found using [Wolfram Alpha](https://www.wolframalpha.com/input?i=sum+from+i%3Dx+to+%28x%2Br%29+of+i%5E2), then golfed as hard as I could.
[Answer]
# JavaScript (ES6), 50 bytes
Returns \$0\$ or \$1\$.
```
f=(n,p=0,q)=>n?++p<n&&f(n-p*p,p,q?1:f)|!q*f(n,p):q
```
[Try it online!](https://tio.run/##FYpBDoIwEADvvGK9NF1aTPEIVN5CsGs0zXYLxIv69lpPM5nMc3kt@7o95Og43UIp5DVb8c5m9FeejZGJlSLNnbRixea5Hwg/p9zSf8QhF0qbjuEABg@XsWKC3rkqxiC8G4B6IigFa@I9xXCO6V7L2HzLDw "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (          // f is a recursive function taking:
  n,           //   n = input
  p = 0,       //   p = counter used to generate squares
  q            //   q = flag telling that we've started to subtract
               //       squares from n, initially undefined, then
) =>           //       set to f, then set to 1
n ?            // if n is not 0:
  ++p < n      //   increment p and abort if it's greater than
  &&           //   or equal to n
  f(           //   otherwise, do a 1st recursive call:
    n - p * p, //     subtract p² from n
    p,         //     pass p unchanged
    q ? 1 : f  //     set q to 1 if it's already defined or
               //     to f (truthy but NaN'ish) otherwise
  ) |          //   end of recursive call
  !q *         //   if q is defined, ignore the result of ...
  f(n, p)      //   ... the 2nd recursive call where n and p are
               //   left unchanged and q is undefined
:              // else:
  q            //   return q, which is coerced to 1 by the bitwise
               //   OR if and only if it's equal to 1, meaning
               //   that n is the sum of at least 2 squares
```
[Answer]
# [Factor](https://factorcode.org/) + `grouping.extras`, ~~60~~ 58 bytes
```
[ dup [1,b] 2 v^n tail-clump [ cum-sum rest ] gather in? ]
```
[Try it online!](https://tio.run/##NY27CsJAEEV7v@J@gAkmPkAtLMXGRqwkwrqOcTG7rjOzoojfHiPirQ6HA/dkrF653W5W6@UMF@JADbzRc84m1CQ/vtO3EtR8TdGFOqeHshEI3RIF@89EjTpRZwWRSfUZ2QXtKhXMe70XxiiGKEYoxyinGA7w3QhF5yd4tzscU8Su6B8qlLjvA9S4JrNN8p2GTT6T5MEkigp1d0kMFxaoWm8i8vYD "Factor – Try It Online")
```
dup             ! duplicate input
[1,b]           ! range from 1 to input inclusive
2 v^n           ! square each
tail-clump      ! suffixes
[               ! begin gather
    cum-sum     ! cumulative sum
    rest        ! sans the first element
] gather        ! map, flatten, and uniqueify
in?             ! is the input we duped at the beginning in the sequence?
```
[Answer]
# [Python](https://docs.python.org/3.8/), 55 bytes
```
f=lambda n,z=0,j=0:j*j<n and f(n,z<<j*j|1,j+1)or z&z>>n
```
[Try it online!](https://tio.run/##FctBCoAgFEXReav4o8hykEQQoe3FKCupl4iTpL2bzS4HrnvCfqMbnE/JqFNf86IJPKqWW9WOtrYSpLGQqbJKmeEV3DaC3Z5iGacJyeQEHSCvsa2V4L1gY0HOHwj5@lfG0gc "Python 3.8 (pre-release) – Try It Online")
Outputs 0 for falsey, nonzero for truthy.
Based on [loopy walt's method](https://codegolf.stackexchange.com/a/257475/20260) of making a set of the cumulative sums of squares, then intersecting it with a copy that's shifted by `n`. This answer represents the set as a bit field stored as a positive number, which lets us shift it with `>>` and intersect with bitwise `&`.
**53 bytes**
```
f=lambda n,z=0,j=0:z&z>>n|(j*j<n>0<f(n,z<<j*j|1,j+1))
```
[Try it online!](https://tio.run/##DYtBCoAgEADvvWJPoeVBiSBC/YtRVlKbiJekv9seh5mJbz4eHKaYavXmcveyOkBRjBTByLm0xVr8WOiCRiu1Z@S0JvyUCL3ivPonAcKJkBzuG1NiVHxuIKYTM9VAC1U/ "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [J](http://jsoftware.com/), 19 bytes
```
e.[:,@(>:+/\*:)1+i.
```
[Try it online!](https://tio.run/##FYwxDsIwEAR7v2ITCsf4OOIkjuWTQAgkKkRBC1QoEdDwA75ujmK0u1Psu@RKwn2sJFtrarYzNgILQgtRVozD5XQsE1@Fds1W/Pq2FBf8i4sz5z0jEkKvDIROe5cJfUsYAiFqRvVR/ag7JTM9nh80i@9ce4f/S0rlBw "J – Try It Online")
Brute force: tries every possible infix of all the squares up to n.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 15 bytes
```
Ｎθ⊙θ⊙ι⁼θΣＸ…·λι²
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iOSOxKDk_MWfBgqWlJWm6FjfDPPMKSkv8SnOTUos0CjWtuQKKMvNKNBzzKjUKdRRAVKaOgmthaWJOMUgguDRXIyC_HKjWMy85p7Q4syw1KDEvPVUjR0chU1NHwUgTDKyXFCclF0PtWB6tpFuWoxS7yNQAIgAA) Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` if `n` can be written as a sum of at least `2` consecutive squares, nothing if not. Explanation:
```
Ｎθ              Input `n` as a number
   θ            Input `n`
  ⊙             Any of implicit range satisfies
     ι          Current value
    ⊙           Any of implicit range satisfies
          …·    Inclusive range from
            λ   Inner value to
             ι  Outer value
         Ｘ      Raised to power
              ² Literal integer `2`
        Σ       Take the sum
      ⁼         Equals
       θ        Input `n`
                Implicitly print
```
Although the program includes `0²` the only relevant sum is `0²+1²` but when the input is `1` the outer loop only goes up to `0` so that sum is never constructed.
[Answer]
# [R](https://www.r-project.org), 41 bytes
```
\(n)n%in%diffinv(array(1:n,1:0+n)^2)[-2,]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3NWM08jTzVDPzVFMy09Iy88o0EouKEis1DK3ydAytDLTzNOOMNKN1jXRiIRr2p2mYanKlaZhocpVnZCZnaBQnFhTkgNSbGuikaWpCVC1YAKEB)
This is mostly a golf of [pajonk's answer](https://codegolf.stackexchange.com/a/257472/67312) that uses `diffinv(X)` rather than `apply(X,2,cumsum)` to calculate the cumulative sums.
### Changes from pajonk's answer:
3. Take the [discrete integral](https://www.rdocumentation.org/packages/stats/versions/3.6.2/topics/diffinv) of the columns. We don't care about the additional values in the bottom-right triangle of the matrix, as those are bigger than `n^2` (which is bigger than `n`), nor do we care about the additional row of zeros at the beginning (since they are smaller than `n`).
```
 0    0    0    0    0
 1    4    9   16   25
 5   13   25   41   26
14   29   50   42   30
30   54   51   46   39
55   55   55   55   55
56   59   64   71   80
```
4. Discard the second row, as it contains squares (not constructed as sums of squares).
[Answer]
# [Python](https://www.python.org), 111 102 95 90 87 bytes
This uses `p` (positive) and `a` (antipositive?) to track the the beginning and end of a series of consecutive squares, only storing the sum (`s`) of squares between them.
If the sum is less then `n`, the square of `p` is added to the sum and `p` is incremented.
If the sum is greater than `n`, the square of `a` is subtracted from the sum and `a` is incremented.
When `p` is greater than `n`, the number has failed the test.
`p-a` is checked to see that at least 2 squares are included in the sum.
102 thanks to l4m2
90 thanks to gsitcia
```
f=lambda n,s=0,p=1,a=1:s!=n>p and f(n,s+[-a*a,p*p][x:=s<n],p+x,a+(x<1))or(s==n)&(p-a>1)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NY4xCsJAEABrfcUJInvJBnKFICGbb1gEi5V4eqCb5S5CfItNGv2Tv9Ei1jMM83zrY7j0Mk2v--CL3Wfv6cq3Y8dGMFGJSg6ZXJVWJI0als54-KG8LThj1EwP7VhRquWAmo_IOYy1s7aPkIjEbkALbpyd82vfRxNMEBNZzidwuC1ttVxoDDJAQA_Bzu5_6Qs)
[Answer]
# Haskell, 51 bytes
```
f x=elem x[sum$map(^2)[z..w]|z<-[1..x],w<-[z+1..x]]
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 44 bytes
```
!FreeQ[Tr/@Subsequences[Range@#^2,{2,#}],#]&
```
function that returns true-false
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277X9GtKDU1MDqkSN8huDSpOLWwNDUvObU4OigxLz3VQTnOSKfaSEe5NlZHOVbtf0BRZl6JQ3BqTmpyCURFtKGOoYFBrI5CerRyrK1tSFFpqoJa7P//AA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~48~~ 38 bytes
```
.+
$*
((^1|11\2)+)(?<1>\1(?<2>11\2))+$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wX0@bS0WLS0MjzrDG0DDGSFNbU8PextAuxhBIGdmBhTS1Vf7/NzTiMjTmMjThMjTlMrLgMrLkMjbgMjYEAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: Vaguely based on my Retina 0.8.2 answer to [Sum of two squares](https://codegolf.stackexchange.com/questions/242459).
```
.+
$*
```
Convert to unary.
```
((^1|11\2)+)
```
Match a square number.
```
(?<1>\1(?<2>11\2))+
```
Match at least one additional consecutive square number; "named" capturing groups are used to reuse the captures from the previous square number.
```
$
```
Check whether the squares are able to sum to the input.
[Answer]
# [Desmos](https://desmos.com/calculator), 54 bytes
```
f(N)=∑_{n=1}^N∑_{k=1}^N0^{(N-∑_{a=n}^{n+k}aa)^2}
```
[Try It On Desmos!](https://www.desmos.com/calculator/ueblkbthmg)
[Try It On Desmos! - Prettified](https://www.desmos.com/calculator/nuve8w4bla)
[Answer]
# [Desmos](https://www.desmos.com), ~~76~~ ~~60~~ 58 bytes
```
l=[1...n]
f(n)=[0^{([a...a+b]^2.total-n)^2}fora=l,b=l].max
```
[Try it on Desmos!](https://www.desmos.com/calculator/8ppdolt62d)
Outputs 0 or 1.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 8 bytes
```
⟦sṀ^₂ᵐ+?
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9H8ZcUPdzbEPWpqerh1grb9///GBv8B "Brachylog – Try It Online")
Tried a more declarative approach instead of this one but the constraint solver is not strong enough for anti-sums, it falls into infinite loops for falsy cases.
### Explanation
```
⟦          Range [0, …, N]
 sṀ        Sublist of Ṁany (i.e. at least 2) consecutive elements 
   ^₂ᵐ     Map square
      +?   The sum is N
```
[Answer]
# Java 8, 84 bytes
```
n->{int i,j,c,r=c=i=0;for(;i<n;c=i*i)for(j=++i;j<n;r+=c==n?1:0)c+=j*j++;return r>0;}
```
[Try it online!](https://tio.run/##NU/LbsMgEDzbX7FHExzLrdRLCekPpKccqx4IsaOlBCLAkSqLb3fXj@4F7cwwO2PUU@3N9Wd6DBeLGrRVMcKnQgdjWQINutSFXukOTgTBNhfvbacc9BXx4JhYmLx@iUkl8jqBBTm5/XGcNVibWtdBaomyFb0PlcCDE7TukM2rkZyjMIQFTirpPl7eW6a5NDvDuQhdGoKDcGxFntZzW@bt3NPjFe6UvDqngO729Q0q3CIby2K2XzLIVwF4kG8tPZwzKlQsHfvKNlSFLUhx/o2puzd@SM2DnJJ1RIlVmssi/3fN0x8 "Java (JDK) – Try It Online")
---
For the science : inline solution using only Streams :
```
n->java.util.stream.IntStream.range(1,n).anyMatch(i->java.util.stream.IntStream.range(i+1,n).anyMatch(j->n==java.util.stream.IntStream.range(i,j+1).reduce(0,(a,b)->a+b*b)))
```
[Answer]
# SWI-Prolog, 64 bytes
```
\X:-X/_. X/Y:-between(2,X,Y),Z is Y-1,W is X-Y*Y,(W is Z*Z;W/Z).
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
LnIKŒOIå
```
[Try it online](https://tio.run/##yy9OTMpM/f/fJ8/T@@gkf8/DS///NzQBAA) or [verify all test cases](https://tio.run/##yy9OTMpM/R9panB0R1mlvZLCo7ZJCkr2lf998iq9j07yrzy89L/OfwA).
Minor alternative:
```
<tLnŒOIå
```
[Try it online](https://tio.run/##yy9OTMpM/f/fpsQn7@gkf8/DS///NzQBAA) or [verify all test cases](https://tio.run/##yy9OTMpM/R9panB0R1mlvZLCo7ZJCkr2lf9tSnzyjk7yrzy89L/OfwA).
More original, but longer (and slower) program (**9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)**):
```
Åœ¨t€¥PΘà
```
[Try it online](https://tio.run/##AR0A4v9vc2FiaWX//8OFxZPCqHTigqzCpVDOmMOg//8xNA) or [verify all test cases](https://tio.run/##AS0A0v9vc2FiaWX/WTUwxbh2eT8iIOKGkiAiP3n/w4XFk8KodOKCrMKlUM6Yw6D/LP8).
**Explanation:**
```
L         # Push a list in the range [1, (implicit) input]
 n        # Square each inner integer
  IK      # Remove the input-integer from the list
    Œ     # Get all sublists
     O    # Sum each sublist
      Iå  # Check if the input-integer is in this list of sums
          # (after which the result is output implicitly)
<         # Decrease the (implicit) input-integer by 1
 t        # Pop and take the square root of this input-1
  L       # Pop and push a list in the range [1, floor(sqrt(input-1))]
   n      # Square each inner integer
    ŒOIå  # Same as above
Åœ        # Get all lists of positive integers that sum to the (implicit) input
  ¨       # Remove the last [...,[input]] sub-list
   t      # Get the square root of each inner integer
    €     # Map over each inner list of decimals:
     ¥    #  Pop and push its deltas / forward-differences
      P   # Get the product of each inner list of forward-differences
       Θ  # Check for each product if it's equal to 1 (with a 05AB1E-truthify)
        à # Check if any is truthy
          # (after which the result is output implicitly)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 82 bytes
```
i;j;s;t;f(n){for(s=i=0;s-n&&++i<n;)for(s=i*i,t=j=i;!t*s-n&&++j<n;t=0)s+=j*j;s-=n;}
```
[Try it online!](https://tio.run/##lVDLTsMwELz3K7aRWjkvkRZxQK65IL6C5BA5dnEAp7KNiIjy64TNE1rBAWu9Ws/MrrzD4yPnXadoSS11VBLtN7IyxDLFEmpjvd2GoTpo6k9ooCLHSqbo2gUTXSLtWOLbkJUBzomZpm2ntIPXXGniQ7MCPD0g6pPgThSPGTBokgjG2M3FRez@pn7t/a/@kmrp8FNeaeuAP@UmwCz4szDjh720ftin9e093hsvgp/va2/qRqOA9MsqXYga2xI6lQew6kNUksw2@FcTECwIBfS7V8@2zdY5nDSOCWFPzyiL1FoS55/DAuHF8KE1@xacDEok8TYFxHeAeWNTjSu5CGy0bG0ZE9k0th2yEe7NaNxp1XafXL7kR9vF718 "C (gcc) – Try It Online")
Inputs \$n\$.  
Returns a falsey value if \$n\$ is the sum of consecutive squares or a truthy value otherwise.
[Answer]
# [///](https://esolangs.org/wiki////), 39 bytes
```
/13///14///25///29///30///41///50///5//
```
[Try it online!](https://tio.run/##K85JLM5ILf7/X9/QWF9f39AESBiZgghLIGFsACRMDIGEKYgFFP9vbPofAA "/// – Try It Online")
*Sigh.*
I thought there was some light at the end of the tunnel with [this idea](https://tio.run/##nYs7koMwEAVznYJYidBfhDb2QTZw1Qabcf9iG9gPNggkK9C86dczfH0Mn49hHJXMPXVRm1JdV0z1y6JuTHVX6nLtidPgX3J/u89kBvPON7Gx0Y0UjWkkv@VnuGkw/TwJYQmk@JOI6TeSu78shW7/Fza92ljNemW3TzvAPQOIfyGg8IpgccOAaQuh3Q6VwrR7GK53OYXZL2hspqFyuYrOZzvKkC9p40FLnY5q@u6wl8K2xwKGPjFQzJmCY08dJHcuYfkCCy2UaHixyENMZSJmV2hK4dpSFVcXu8imXMa2FTa6q9HxfZXPQag74CJWXnCSak@46apv3juS4zc), but it turns out the simple greedy approach fails for a few of the inputs. Plus, hardcoding it is a third of the length.
]