Nota: Este es el hilo de la policía , donde uno debe publicar el código codificado. Aquí está el hilo de los ladrones donde la fuente descifrada debe publicarse y vincularse a la respuesta del policía.

Tarea: Escriba el programa seguro más corto que multiplique la raíz cuadrada de un entero n por el cuadrado de n

Esto es policías y ladrones , por lo que las reglas son:

• En su respuesta, publique una versión codificada de su código fuente (los caracteres deben escribirse en cualquier orden). ¡La versión codificada no debería funcionar!
• Puede tomar la entrada de cualquier manera estándar, lo mismo ocurre con la salida. La codificación está prohibida
• Después de que los ladrones descifren el código (si esto sucede), debe mencionar que su código ha sido descifrado en su título y agregar un spoiler al cuerpo de su respuesta con su código exacto
• Lo mismo se aplica a las respuestas seguras (mencione que es seguro y agregue el spoiler )
• El código se considera seguro si nadie lo ha descifrado en 5 días después de publicarlo y puede especificarlo opcionalmente en el título
• Debes especificar tu lenguaje de programación
• Debe especificar su recuento de bytes
• Debe indicar el mecanismo de redondeo en su respuesta (ver más abajo)

Se puede suponer que el resultado es menor que 2 ³² y n es siempre positivo. Si el resultado es un entero, debe devolver el valor exacto con o sin un punto decimal; de lo contrario, la precisión decimal mínima será de 3 decimales con cualquier mecanismo de redondeo que elija, pero puede incluir más. Debe indicar el mecanismo de redondeo en su respuesta.No puedes regresar como fracciones (numerador, pares de denominador - ¡lo siento, Bash!

Ejemplos:

In -> Out

4 -> 32.0 (or 32)
6 -> 88.18163074019441 (or 88.182 following the rules above)
9 -> 243.0
25 -> 3125.0

La respuesta segura más corta para fines de abril será considerada la ganadora.

05AB1E, 20 bytes - seguro

Otro enfoque totalmente diferente de mis respuestas anteriores.

****++/133DDFPTs}¹¹Ð

Sin redondeo.

Ejecuciones de ejemplo

In   -> Out
0    -> 0
4    -> 32.0
6    -> 88.18163074019441
25   -> 3125.0
7131 -> 4294138928.896773

No tengo dudas de que @Emigna lo va a romper en un santiamén, ¡pero hay que intentarlo! :-RE

Solución

D1TFÐ*D¹3*+s3*¹+/*}P

Esto está usando el hecho de que esta secuencia:

u_0 = 1, u_ {n + 1} = u_n * (u_n ^ 2 + 3 x) / (3 u_n ^ 2 + x)

converge a sqrt (x), y cúbicamente rápido (perdón, no encontré cómo formatear ecuaciones matemáticas en PCG).

Explicación detallada

D1TFÐ*D¹3*+s3*¹+/*}P
D1                   # Duplicate the input, then push a 1: stack is now [x, x, 1] (where x is the input)
  TF                 # 10 times (enough because of the cubic convergence) do
    Ð                # triplicate u_n
     *               # compute u_n ^ 2
      D              # and duplicate it
       ¹3*+          # compute u_n ^ 2 + 3 x
           s         # switch that last term with the second copy of u_n ^ 2
            3*¹+     # compute 3 u_n ^ 2 + x
                /    # compute the ratio (u_n ^ 2 + 3 x) / (3 u_n ^ 2 + x)
                 *   # compute u_n * (u_n ^ 2 + 3 x) / (3 u_n ^ 2 + x), i.e. u_{n+1}, the next term of the sequence
                  }  # end of the loop
                   P # compute the product of the whole stack, which at that point contains u_10 (a sufficiently good approximation of sqrt(x)), and the 2 copies of the input from the initial D: we get x ^ 2 * sqrt(x)

Pruébalo en línea!

Python 3 , 44 bytes ( agrietado )

'**:(((paraboloid / rabid,mad,immoral))):**'

Sin redondeo. Precisión de punto flotante.

MATL , 12 bytes ( descifrado por @tehtmi )

'Un&0P'/^:+1

Sin redondeo; usa punto flotante.

Solución prevista (diferente de la encontrada por @tehtmi):

:&+n10U'P'/^

Explicación

:&+ % Create a matrix of size n × n, where n is implicit input
n % Number of elements. Gives n^2
10U % 10 squared. Gives 100
'P' % 'P' (ASCII code 80)
/ % Divide. Gives 1.25
^ % Power. Implicit display

Röda , 28 bytes ( Agrietado por @tehtmi )

 (),.025^^cdfhnnnopprstuu{|}

Tenga en cuenta el espacio al principio. Sin redondeo, pero utiliza números de coma flotante, por lo que la precisión es limitada.

Perl, 42 bytes (Seguro)

Hay 41 bytes de código y -pbandera (no hay otras banderas).

/"/4~~r..rso4r<_$4va=eg1de|i/h0-&$c={}l+"

El resultado no es redondeado (o más bien redondeado al mismo punto que Perl habría redondeado haciendo $_ = (sqrt $_) * ($_ ** 2)).

Solución:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(sin el \anterior &spoiler de reducción parece que no le gusta $seguido &) ¡
Pruébelo en línea!

Explicación:

.i44<4}{|~es $_**2*sqrtpero con cada carácter reemplazado por el carácter con su código ascii + 10. (código ascii de $is 36, entonces se convierte en .cuyo código ascii es 46, etc.).
El propósito de s/./chr-10+ord$\&/grees deshacer esta transformación: reemplaza cada carácter por el carácter con el código ascii 10 más bajo. ( chr-10+ord$\&es probable que sea más claro porque chr(ord($\&)-10)where chrdevuelve el carácter correspondiente a un código ascii y orddevuelve el código ascii correspondiente a un carácter).
finalmente, evalevalúa esta cadena y, por lo tanto, calcula el resultado, que se almacena en $_, que se imprime implícitamente al final gracias a -pflag.

Octava, 43 bytes (Seguro)

$'()*+,-/23579:[]aelnouv'*,-23:[]lu',-23]',

Este es un script que requiere la entrada de la línea de comando (no es una función). Es la precisión de coma flotante (por lo que no hay redondeo).

Solución:

eval(-[5,-2:3,-3:2]+['nlouu*$$',39,']2/7'])

Explicación:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Todo dentro de la evalllamada se evalúa a input('')^2.5

¿Cómo?

-[5,-2:3,-3:2] % A vector: [-5, 2, 1, 0, -1, -2, -3, 3, 2, 1, 0, -1, -2]
['nlouu**$$',39,']2/7'] % This is a string: nlouu**$ concatenated with the number
. % 39 (ASCII ']'), and ']2/7'. Thus, combined: 'nlouu**$$']2/7'

Agregar el primer vector a esta cadena lo convertirá en el vector entero:
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalimplícitamente convierte esto en una cadena, y estos números resultan ser: input('')^2.5

C, 50 bytes ( agrietado por fergusq )

%(())   ,-12225;>\\aaabbdddeeefffllnoooprrttuuuuw{

Utiliza el redondeo estándar IEEE754. Como se señala en la respuesta de fergusq, puede requerir -lmdependiendo de su compilador.

Mathematica, 131 bytes, ¿no compite ?, agrietado

¡Esto ha sido descifrado por @ lanlock4 ! Sin embargo, todavía tengo puntos de Internet para otorgar a alguien que encuentre la solución original, donde realmente se necesitan todos los personajes ...

f[y_]:=With[{x=@@@@@@#####^^&&&(((()))){{}}111111,,+-/y},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

Esto pretende ser un rompecabezas. Aunque puede usar los caracteres anteriores como desee, ciertamente tengo la intención de que la respuesta siga el formulario

f[y_]:=With[{x=
    @@@@@@#####^^&&&(((()))){{}}111111,,+-/y
},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

donde la primera y la tercera línea son solo un contenedor para hacer que el redondeo y la visualización sean legales (escribe cada salida con exactamente tres decimales, redondeados), y la segunda línea es la versión codificada de las tripas del código. Resultados de muestra:

6 -> 88.182
9 -> 243.000
9999 -> 9997500187.497

(Mathematica is non-free software, but there is a Wolfram sandbox where it is possible to test modest amounts of code. For example, cutting and pasting the code

f[y_]:=With[{x=
    y^2.5
},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

defines a function, which you can subsequently call like f@6 or f[9], that does the same thing as the unscrambled version of the code above. So does this really have to be non-competing?)

Swift - 64 bytes (seguro)

prot Fdnufi;nooitamunc xetgru(->atl)Ior:n{tFn pg,F(ao.o25t)(w)l}

No rounding, and displays a .0 even if the result is an integer.

Haskell, 16 bytes ( Agrietado por @nimi )

()*...25=eglopxx

Sin redondeo particular

R, 28 bytes (Cracked by @Flounderer)

funny(p1)-tio(^*^)/pc(2)<p2;

Standard R floating-point accuracy.

C#, 172 bytes (Cracked by SLuck49)

       (((((())))))***,,,,......1225;;;;;;<====>CFLMMMMMPPPRSSSSSWaaaaaaabbbbcccddddddeeeeeeeeeeegghiiiiiiiillllllmmnnnnnnnooooooooqqqqrrrssssssssstttttttttuuuuuuuvvwyy{{}}

This code is a full program.

There are seven space characters at the start.

The input is read form STDIN and printed to STDOUT. The result is in double, no rounding done.

Original Code ungolfed:

using System;
using S = System.Console;

class P
{
    static void Main()
    {
        var t = S.ReadLine();
        double q = int.Parse(t);
        Func<double, double, double> M = Math.Pow;
        S.Write(M(q, 2 * .25) * M(q * q, 1));
    }
}

JavaScript (ES7), 20 bytes (Cracked by @IlmariKaronen)

****..22255666=>____

Standard JavaScript precision.

Python 2, 60 Bytes (Cracked by @notjagan)

 3n0)4  5)594p3(p5*5i9t4542)0/*((8(t.84- 90945 u)i*48/95n8r8

No rounding involved. Accurate up to 10 decimal digits.

Python 3.6, 59 bytes

ba(,b5,d' (,a/([m:'-)oa)(bl*aadplma dba](r)d )l*d,:)*m:-mml

No rounding. Floating point accuracy.

Haskell, 64 bytes, (cracked by Laikoni)

$$$$$$(((((())))))**,...0<<<>>>[]cccccdddeffiiiiilloopppprrsstuu

Standard Haskell floating point operations.

My original version is:

product.((($succ$cos$0)(flip(**).)[id,recip])).flip(id)

Fourier, 124 119 Bytes

((()))*******--011111<=>>>HHINNNN^^^eeehhhhkkkkmmmmmmmmmmmmmmmmossuuuuuuuuuuuuuuuuu{{{{{{{{{{}}}}}}}}}}~~~~~~~~~~~~~~~~

There are no whitespaces or newline characters.

Square root is rounded to the nearest whole number because Fourier doesn't seem to handle anything other than integers (and since @ATaco got permission, I hope this is ok)

fixed an editing mistake, if you were already cracking this, the previous was functional

Realized that I had misunderstood part of the code, and was using more characters than I needed to

If I missed anything let me know

Inform 7, 71 bytes (Cracked by @Ilmari Karonen)

""()**-..:[]
                 RT
aaaabeeeffilmmnnnnnooooooqrrrrrssstuuy

The code includes 17 spaces and 2 new lines. This is a full Infrom 7 program defining a function that prints the result with a precision of 5 decimal places.

R, 19 bytes (Cracked by @Steadybox)

mensana(4*5*c(.1)):

Standard rounding

R, 33 bytes (Cracked by @plannapus)

(rofl(17)^coins(2*e)/pisan(10))--

R, 31 bytes (Cracked by @plannapus)

h=f`l`u`n`c`t`i`o`n([],[])^(.9)

Octave, 30 bytes (Safe)

(((((())))))**++/:@eeeiiijmsu~

A bit simpler than my first one. Shouldn't be too hard, but it's hopefully a fun puzzle.

Ohm, 11 bytes

M ⁿ¡D¼½;+1I

Use with -c flag. Uses CP-437 encoding.

OCaml, 13 bytes (Cracked by @Dada)

2*fn-5f>f*u .

No rounding (within IEEE 754 scope).

Javascript, 123 bytes, Cracked by notjagan

 """"""((((((((()))))))))********,--.....//2;;======>>Seeeeeeegggggggggggghhhhhhhhhhhilllllnnnnnnnnnnorrrsstttttttttttttu{}

This code is a full function

There is one space character at the very start of the list of characters

The rounding of this answer is the floating point precision for Javascript, accuracy is within 10^-6 for every answer.

Got shorter because the precision didn't need to be maintained quite as high as I thought it did.

I had realized that it would be much easier to solve than I initially had made it but it was already there :P

Initial code:

g=t=>t-(t*t-n)/("le".length*t);e=h=>{n=h*h*h*h*h,s=2**(n.toString("ng".length).length/"th".length);return g(g(g(g(g(s)))))}

Newtons method, applied 5 times from the closest power of 2

Python 3.6 - 52 bytes (Cracked by @xnor)

f=lambda x:x**125*77*8+8/5/((('aafoort.hipie.xml')))

Standard Python rounding

Ruby, 35 bytes (cracked by xsot)

'a'0-a<2<e<2<l<3<v<4<4<4<5<5<6>7{9}

No rounding. Floating point accuracy.

05AB1E, 47 bytes

)*.2555BFHIJJKKKPQRST``cgghilnstwx}«¹¹Áöž‚„…………

Does not round, uses floating point accuracy.

CJam, 8 bytes (Cracked by Enmigmna)

WYdYl##+

No rounding. Uses double precision.

R, 32 bytes (Cracked by @plannapus)

i=na*0.5f*n(2*s*cos(t))*22*s*12u

Standard floating-point accuracy.

Excel, 26 bytes

=(())*//11122AAAIINPQRSST^

No rounding.

Note: As Excel is paid software, this works also in free LibreOffice

RProgN 2, 6 Bytes (Cracked by @notjagan)

š2]^*\

No rounding, displays many decimal places. Does not display any for an integer solution.