Given a positive square number as input. Output the number of values between the input and next highest square.
Input: 1
Output: 2
Reason: The numbers 2 and 3 are between 1 and 4, the next highest square
Input: 4
Output: 4
Reason: The numbers 5, 6, 7, 8 are between 4 and 9
{([[]](({})))}{}([]<>)
I'm very proud of this answer. IMO, one of my best brain-flak golfs.
As many other users have pointed out, the answer is simply sqrt(n) * 2. However, calculating the square root in brain-flak is very very nontrivial. Since we know the input will always be a square, we can optimize. So we write a loop that subtracts
1, 3, 5, 7, 9...
from the input, and track how many times it runs. Once it hits 0, the answer is simply the last number we subtracted minus one.
Originally, I had pushed a counter on to the other stack. However, we can use the main stack itself as a counter, by increasing the stack height.
#While TOS (top of stack, e.g. input) != 0:
{
#Push:
(
#The negative of the height of the stack (since we're subtracting)
[[]]
#Plus the TOS pushed twice. This is like incrementing a counter by two
(({}))
)
#Endwhile
}
#Pop one value off the main stack (or in other words, decrement our stack-counter)
{}
#And push the height of the stack onto the alternate stack
([]<>)
In python-y pseudocode, this is basically the following algorithm:
l = [input]
while l[-1] != 0: #While the back of the list is nonzero
old_len = len(l)
l.append(l[-1])
l.append(l[-1] - old_len)
l.pop()
print(len(l))
2Sqrt@#&
Try it online! (Using Mathics.)
The difference between n2 and (n+1)2 is always 2n+1 but we just want the values between them excluding both ends, which is 2n.
This can potentially be shortened to 2#^.5& depending on precision requirements.
½Ḥ
Port of my Mathematica answer (take square root, then double). This is limited to inputs which can be represented exactly as a floating-point number. If that's an issue, the three-byte solution ƽḤ works for arbitrary squares (which Dennis posted first but then deleted).
?2*vp
Previously I misread the question. This version works for any positive integer input, not just perfect squares:
?dv1+d*1-r-p
I missed the "input will be square" caveat, but this will work for all non-negative integers... Martin Ender already gave the 2 byte solution.
½‘Ḟ²’_
A monadic link returning the count.
Shout out to DJMcMayhem's amazing (albiet slightly longer) answer here
{({}()[({}()())])}{}
This code works by counting down from the square number by odd increments. Since every square is the sum of consecutive odd numbers this will reach 0 in n1/2 steps. The trick here is we actually keep track of our steps in an even number and use a static () to offset it to the appropriate odd number. Since the answer is 2n1/2, this even number will be our answer. So when we reach 0 we remove the zero and our answer is sitting there on the stack.
@(n)2*n^.5
Saved 15 bytes by using Martin's much better approach. The range consists of 2*sqrt(n) elements. The function does exactly that: Multiplies 2 with the root of the input.
½‘R²Ṫ_‘
Explanation:
½‘R²Ṫ_ Input: 40
½ Square root 6.32455532...
‘ Increment 7.32455532...
R Range [1, 2, 3, 4, 5, 6, 7]
² Square [1, 4, 9, 16, 25, 36, 49]
Ṫ Tail 49
_‘ Subtract input+1 8
n=>n**.5*2
Try it online! Math.sqrt is pretty long which is why we use **.5
.+
$*
(^1?|11\1)+
$1
Try it online! Explanation: Works by taking the square root of the number based on @MartinEnder's triangular number solver. After matching the square number, $1 is the difference between the square number and the previous square number, in unary. We want the next difference, but exclusive, which is just 1 more. To achieve this, we count the number of null strings in $1.
2√(Ans
Simplest approach...
+?
_
S
+1
^2
-1
-G
O
Do you want to know how it works? Well, fear not! I'm here to educate you!
+? Add the input to x (the accumulator)
_ Store the input in the input list
S Square root
+1 Add 1
^2 Square
-1 Subtract 1
-G Subtract the input
O Output as number
I'm sure this can be reduced significantly (edit: thanks Luis), but a naive solution is:
X^QUG-q
X^ % Take the square root of the input (an integer)
QU % Square the next integer to find the next square
G- % Subtract the input to find the difference
q % Decrement solution by 1 to count only "in between" values.
2^ by U (and this worked in version 20.1.1, which was the most recent at the time of the challenge, so the answer it would be eligible even by our old standard)
\$\endgroup\$
Commented
May 27, 2019 at 9:40
2/*<ER
o@i
Again, computes 2 sqrt(n). The layout saves two bytes over the standard solution:
/o
\i@/2RE2*
Breakdown of the code, excluding redirection of the IP:
2 Push 2 for later.
i Read all input.
i Try reading more input, pushes "".
2 Push 2.
R Negate to get -2.
E Implicitly discard the empty string and convert the input to an integer.
Then take the square root of the input. E is usually exponentiation, but
negative exponents are fairly useless in a language that only understands
integers, so negative exponents are interpreted as roots instead.
* Multiply the square root by 2.
o Output the result.
@ Terminate the program.
?sqr(:)*2
Saved a bunch by copying @MartinEnder's approach.
No TIO link for QBIC, unfortunately.
? PRINT
sqr( ) The square root of
: the input
*2 doubled
n->2*Math.sqrt(n)
Note: This would require import java.util.function.*; to get IntFunction<T> in Java 8 or Java 9, but the java.util.function package is imported by default in JShell.
I.5^2*P
Just the same as every other answer: outputs two times the square root.
