Nota: Este é o tópico da polícia , onde deve-se postar o código codificado. Aqui está o tópico dos ladrões onde a fonte quebrada deve ser postada e vinculada à resposta do policial.

Tarefa: Escreva o programa seguro mais curto que multiplique a raiz quadrada de um número inteiro n pelo quadrado de n

Isso é polícia e ladrão , então as regras são:

• Na sua resposta, publique uma versão codificada do seu código-fonte (os caracteres devem ser escritos em qualquer ordem). A versão codificada não deve funcionar!
• Você pode receber entradas de qualquer maneira padrão, o mesmo vale para a saída. A codificação é proibida
• Depois que o código for decifrado pelos ladrões (se isso acontecer), você deve mencionar que seu código foi decifrado em seu título e adicionar um spoiler ao corpo da sua resposta com o código exato
• O mesmo se aplica a respostas seguras (mencione que é seguro e adicione o spoiler )
• O código é considerado seguro se ninguém o tiver decifrado em 5 dias após a publicação e você pode opcionalmente especificar isso no título
• Você deve especificar sua linguagem de programação
• Você deve especificar sua contagem de bytes
• Você deve indicar o mecanismo de arredondamento na sua resposta (veja abaixo)

Você pode assumir que o resultado é inferior a 2 ³² e n é sempre positivo. Se o resultado for um número inteiro, você deve retornar o valor exato com ou sem um ponto decimal; caso contrário, a precisão decimal mínima será de 3 casas decimais com qualquer mecanismo de arredondamento de sua escolha, mas poderá incluir mais. Você deve indicar o mecanismo de arredondamento na sua resposta. Você não tem permissão para retornar como frações (numerador, pares de denominadores - desculpe, Bash!)

Exemplos:

In -> Out

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

A resposta mais curta e segura até o final de abril será considerada a vencedora.

05AB1E, 20 bytes - seguro

Outra abordagem totalmente diferente das minhas respostas anteriores.

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

Sem arredondamento.

Execuções de exemplo

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

Não tenho dúvida de que @Emigna vai rachar em um instante, mas eh, é preciso tentar! :-D

Solução

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

Isso está usando o fato de que esta sequência:

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

converge para sqrt (x) e, de maneira cúbica, rápido (desculpe, não encontrou como formatar equações matemáticas no PCG).

Explicação detalhada

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)

Experimente online!

Python 3 , 44 bytes ( quebrado )

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

Sem arredondamento. Precisão de ponto flutuante.

MATL , 12 bytes ( quebrado por @tehtmi )

'Un&0P'/^:+1

Sem arredondamento; usa ponto flutuante.

Solução pretendida (diferente da encontrada por @tehtmi):

:&+n10U'P'/^

Explicação

:&+ % 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 ( Rachado por @tehtmi )

 (),.025^^cdfhnnnopprstuu{|}

Observe o espaço no início. Sem arredondamento, mas ele usa números de ponto flutuante, portanto a precisão é limitada.

Perl, 42 bytes (Seguro)

Existem 41 bytes de código e -psinalizador (nenhum outro sinalizador).

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

O resultado não é arredondado (ou melhor, arredondado para o mesmo ponto que o Perl teria arredondado fazendo $_ = (sqrt $_) * ($_ ** 2)).

Solução:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(sem o spoiler \antes da &remarcação parece não gostar, $seguido por &)
Experimente online!

Explicação:

.i44<4}{|~é $_**2*sqrtmas com cada caractere substituído pelo caractere com seu código ASCII + 10. (código ASCII de $é 36, então ele se torna .cujo código ASCII é 46etc.).
O objetivo de s/./chr-10+ord$\&/greé então desfazer essa transformação: ela substitui cada caractere pelo caractere pelo código ascii 10 inferior. ( chr-10+ord$\&provavelmente é mais claro, pois chr(ord($\&)-10)where chrretorna o caractere correspondente a um código ascii e ordretorna o código ascii correspondente a um caractere).
por fim, evalavalia essa string e, assim, calcula o resultado armazenado $_, que é implicitamente impresso no final graças à -pflag.

Oitava, 43 bytes (Seguro)

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

Este é um script que requer entrada da linha de comando (não é uma função). É precisão de ponto flutuante (sem arredondamento).

Solução:

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

Explicação:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Tudo dentro da evalchamada é avaliado como input('')^2.5

Como?

-[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'

Adicionar o primeiro vetor a esta string o converterá no vetor inteiro:
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalconverte implicitamente isso em uma string, e esses números são assim: input('')^2.5

C, 50 bytes ( Rachado por fergusq )

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

Usa o arredondamento IEEE754 padrão. Conforme observado pela resposta de fergusq, pode exigir-lm dependendo do seu compilador.

Mathematica, 131 bytes, não concorrente ?, rachado

Isso foi quebrado por @ lanlock4 ! No entanto, ainda tenho pontos de internet para conceder a alguém que encontre a solução original, onde todos os personagens são realmente necessários ...

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

Isto é planejado como um quebra-cabeça. Embora você possa usar os caracteres acima como quiser, certamente pretendo que a resposta siga o formulário

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

onde a primeira e a terceira linhas são apenas um invólucro para tornar o arredondamento e a exibição legais (ele grava todas as saídas exatamente com três casas decimais, arredondadas), e a segunda linha é a versão codificada das tripas do código. Saídas de amostra:

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

(O Mathematica é um software não-livre, mas existe uma caixa de proteção Wolfram onde é possível testar quantidades modestas de código. Por exemplo, cortando e colando o código

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

define uma função, que você pode chamar posteriormente como f@6ou f[9], que faz a mesma coisa que a versão sem codificação do código acima. Então, isso realmente precisa ser não competitivo?)

Swift - 64 bytes (Seguro)

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

Sem arredondamento e exibe um .0mesmo se o resultado for um número inteiro.

Haskell, 16 bytes ( Rachado por @nimi )

()*...25=eglopxx

Nenhum arredondamento específico

R, 28 bytes ( Rachado por @Flounderer )

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

Precisão de ponto flutuante padrão R.

C #, 172 bytes ( Rachado por SLuck49 )

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

Este código é um programa completo.

Existem sete caracteres de espaço no início.

A entrada é lida no formulário STDIN e impressa em STDOUT. O resultado é double, sem arredondamentos.

Código original não destruído:

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 ( Rachado por @IlmariKaronen )

****..22255666=>____

Precisão JavaScript padrão.

Python 2, 60 bytes ( rachado por @notjagan )

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

Nenhum arredondamento envolvido. Precisos até 10 dígitos decimais.

Python 3.6, 59 bytes

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

Sem arredondamento. Precisão de ponto flutuante.

Haskell, 64 bytes, ( rachado por Laikoni )

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

Operações padrão de ponto flutuante Haskell.

Minha versão original é:

produto. ((($ succ $ cos $ 0) (flip (**).) [id, destinatário])). flip (id)

Fourier , 124 119 bytes

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

Não há espaços em branco ou caracteres de nova linha.

A raiz quadrada é arredondada para o número inteiro mais próximo porque Fourier parece não manipular nada além de números inteiros (e, como @ATaco obteve permissão, espero que esteja tudo bem)

Foi corrigido um erro de edição. Se você já estava decifrando isso, o anterior era funcional

Percebi que havia interpretado mal parte do código e estava usando mais caracteres do que precisava para

Se eu perdi alguma coisa, me avise

Informar 7 , 71 bytes ( Rachado por @Ilmari Karonen )

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

O código inclui 17 espaços e 2 novas linhas. Este é um programa completo do Infrom 7 que define uma função que imprime o resultado com uma precisão de 5 casas decimais.

R, 19 bytes (Rachado por @Steadybox)

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

Arredondamento padrão

R, 33 bytes (Rachado por @plannapus)

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

R, 31 bytes (Rachado por @plannapus)

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

Oitava, 30 bytes (Seguro)

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

Um pouco mais simples que o meu primeiro. Não deve ser muito difícil, mas espero que seja um quebra-cabeça divertido.

Ohm, 11 bytes

M ⁿ¡D¼½;+1I

Use com -cbandeira. Usa a codificação CP-437.

OCaml , 13 bytes ( Rachado por @Dada )

2*fn-5f>f*u .

Sem arredondamento (dentro do escopo IEEE 754).

Javascript, 123 bytes, Rachado por notjagan

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

Este código é uma função completa

Há um caractere de espaço no início da lista de caracteres

O arredondamento desta resposta é a precisão de ponto flutuante para Javascript; a precisão está dentro de 10 ^ -6 para cada resposta.

Ficou mais curto porque a precisão não precisava ser mantida tão alta quanto eu pensava.

Eu tinha percebido que seria muito mais fácil resolver do que inicialmente o fiz, mas já estava lá: P

Código inicial:

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

Método de Newton, aplicado 5 vezes a partir da potência mais próxima de 2

Python 3.6 - 52 bytes ( Rachado por @xnor )

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

Arredondamento Python padrão

Ruby, 35 bytes (quebrado por xsot )

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

Sem arredondamento. Precisão de ponto flutuante.

05AB1E , 47 bytes

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

Não arredonda, usa precisão de ponto flutuante.

CJam, 8 bytes ( Rachado por E n mig m na )

WYdYl##+

Sem arredondamento. Usa precisão dupla.

R, 32 bytes ( Rachado por @ plannapus )

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

Precisão de ponto flutuante padrão.

Excel, 26 bytes

=(())*//11122AAAIINPQRSST^

Sem arredondamento.

Nota: Como o Excel é um software pago, isso também funciona no LibreOffice.

RProgN 2 , 6 bytes ( rachado por @notjagan )

š2]^*\

Sem arredondamento, exibe muitas casas decimais. Não exibe nenhum para uma solução inteira.