Dado un número cuadrado positivo como entrada. Muestra el número de valores entre la entrada y el siguiente cuadrado más alto.

Ejemplo

Entrada: 1

Salida: 2

Motivo: los números 2 y 3 están entre 1 y 4, el siguiente cuadrado más alto

Entrada: 4

Salida: 4

Motivo: los números 5, 6, 7, 8 están entre 4 y 9

Jalea , 2 bytes

½Ḥ

Pruébalo en línea!

Puerto de mi respuesta de Mathematica (sacar raíz cuadrada, luego doble). Esto se limita a las entradas que se pueden representar exactamente como un número de punto flotante. Si eso es un problema, la solución de tres bytes ƽḤfunciona para cuadrados arbitrarios (que Dennis publicó primero pero luego eliminó).

Brain-Flak , 38 , 22 bytes

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

Pruébalo en línea!

Estoy muy orgulloso de esta respuesta. OMI, uno de mis mejores campos de golf.

¿Como funciona?

Como muchos otros usuarios han señalado, la respuesta es simplemente sqrt (n) * 2 . Sin embargo, calcular la raíz cuadrada en el ataque cerebral no es muy trivial. Como sabemos que la entrada siempre será un cuadrado, podemos optimizar. Entonces escribimos un ciclo que resta

1, 3, 5, 7, 9...

desde la entrada y realizar un seguimiento de cuántas veces se ejecuta. Una vez que llega a 0, la respuesta es simplemente el último número que restamos menos uno.

Originalmente, había empujado un contador a la otra pila. Sin embargo, podemos usar la pila principal en sí misma como contador, aumentando la altura de la pila.

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

En el seudocódigo python-y, este es básicamente el siguiente algoritmo:

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

Mathematica, 8 bytes

2Sqrt@#&

Pruébalo en línea! (Usando matemáticas).

La diferencia entre n ² y (n + 1) ² siempre es 2n + 1, pero solo queremos que los valores entre ellos excluyan ambos extremos, que es 2n .

Potencialmente, esto puede acortarse 2#^.5&según los requisitos de precisión.

Julia 0.5 , 8 bytes

!n=2n^.5

Pruébalo en línea!

dc, 5

?2*vp

Pruébalo en línea .

Anteriormente leí mal la pregunta. Esta versión funciona para cualquier entrada entera positiva, no solo para cuadrados perfectos:

dc, 12

?dv1+d*1-r-p

Pruébalo en línea .

Gelatina ,  7  6 bytes

Me perdí la advertencia de "la entrada será cuadrada", pero esto funcionará para todos los enteros no negativos ... Martin Ender ya dio la solución de 2 bytes .

½‘Ḟ²’_

Un enlace monádico que devuelve el recuento.

Pruébalo en línea!

Japt , 5 3 bytes

¬*2

Pruébalo en línea!

Raíz cuadrada de la entrada, luego multiplique por 2.

Brain-Flak , 20 bytes

Grita a la increíble respuesta de DJMcMayhem (aunque un poco más de tiempo) aquí

{({}()[({}()())])}{}

Pruébalo en línea!

Explicación

Este código funciona contando desde el número cuadrado en incrementos impares. Como cada cuadrado es la suma de números impares consecutivos, alcanzará 0 en n ^1/2 pasos. El truco aquí es que realmente hacemos un seguimiento de nuestros pasos en un número par y usamos una estática ()para compensarlo al número impar apropiado. Como la respuesta es 2n ^1/2 , este número par será nuestra respuesta. Entonces, cuando llegamos a 0, eliminamos el cero y nuestra respuesta está allí en la pila.

Mathematica, 17 bytes

(Sqrt@#+1)^2-#-1&

Pruébalo en línea!

Octava , 25 10 bytes

@(n)2*n^.5

Pruébalo en línea!

Ahorró 15 bytes utilizando el enfoque mucho mejor de Martin. La gama consta de 2*sqrt(n)elementos. La función hace exactamente eso: se multiplica 2con la raíz de la entrada.

Jalea , 7 bytes

½‘R²Ṫ_‘

Pruébalo en línea!

Explicación:

½‘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

Python 3 , 16 bytes

lambda n:2*n**.5

Pruébalo en línea!

Ohm , 2 bytes

√d

Pruébalo en línea!

JavaScript ES6, 10 bytes

n=>n**.5*2

Pruébalo en línea! Math.sqrtes bastante largo, por eso usamos**.5

TI-Basic, 3 bytes

2√(Ans

Enfoque más simple ...

05AB1E , 2 bytes

t·

Pruébalo en línea!

Otro puerto de la presentación de Martin Ender ...

Agregar ++ , 22 20 bytes

+?
_
S
+1
^2
-1
-G
O

Pruébalo en línea!

¿Quieres saber cómo funciona? Bueno, no temas! ¡Estoy aquí para educarte!

+?   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

MATL ( 8 7 bytes)

Estoy seguro de que esto se puede reducir significativamente (editar: gracias Luis), pero una solución ingenua es:

X^QUG-q

Pruébalo en línea!

Explicación:

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.

Pari / GP , 9 bytes

n->2*n^.5

Pruébalo en línea!

PHP , 44 bytes

<?=count(range($argn,(sqrt($argn)+1)**2))-2;

Pruébalo en línea!

Alice , 10 bytes

2/*<ER
o@i

Pruébalo en línea!

Explicación

De nuevo, calcula 2 sqrt (n) . El diseño ahorra dos bytes sobre la solución estándar:

/o
\i@/2RE2*

Desglose del código, excluyendo la redirección de la 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.

Go , 56 bytes

import."math"
func f(n float64)float64{return 2*Sqrt(n)}

Pruébalo en línea!

QBIC , 19 9 bytes

?sqr(:)*2

Ahorré un montón copiando el enfoque de @ MartinEnder.

No hay enlace TIO para QBIC, desafortunadamente.

Explicación

?          PRINT
 sqr( )    The square root of
     :     the input
        *2 doubled

En realidad , 3 bytes

√2*

Pruébalo en línea!

05AB1E , 4 3 bytes

^{Tachado 4 sigue siendo 4: c}

t2*

Pruébalo en línea!

Retina , 21 bytes

.+
$*
(^1?|11\1)+
$1

Pruébalo en línea! Explicación: Funciona tomando la raíz cuadrada del número basado en el solucionador de números triangulares de @ MartinEnder. Después de hacer coincidir el número cuadrado, $1es la diferencia entre el número cuadrado y el número cuadrado anterior, en unario. Queremos la próxima diferencia, pero exclusiva, que es solo 1 más. Para lograr esto, contamos el número de cadenas nulas $1.

T-SQL, 22 bytes

SELECT 2*SQRT(a)FROM t

La entrada es a través de una tabla preexistente, según nuestros estándares .

Java (OpenJDK 9) / JShell, 17 bytes

n->2*Math.sqrt(n)

Pruébalo en línea!

Nota: Esto requeriría import java.util.function.*;obtener IntFunction<T>Java 8 o Java 9, pero el java.util.functionpaquete se importa por defecto en JShell.

Haskell, 9 bytes

(*2).sqrt

Pruébalo en línea

La entrada y la salida se tratarán como valores flotantes.

Noether, 7 bytes

I.5^2*P

Pruébalo aquí!

Igual que cualquier otra respuesta: genera dos veces la raíz cuadrada.