Nota: questo è il thread della polizia , dove si dovrebbe pubblicare il codice criptato. Ecco il thread dei ladri in cui la fonte crackata dovrebbe essere pubblicata e collegata alla risposta del poliziotto.

Compito: scrivere il programma sicuro più breve che moltiplica la radice quadrata di un numero intero n per il quadrato di n

Questo è poliziotti e ladri , quindi le regole sono:

• Nella tua risposta, pubblica una versione criptata del tuo codice sorgente (i caratteri devono essere scritti in qualsiasi ordine). La versione criptata non dovrebbe funzionare!
• Puoi prendere input in qualsiasi modo standard, lo stesso vale per l'output. L'hardcoding è vietato
• Dopo che il ladro ha decifrato il codice (se ciò accade), è necessario menzionare che il codice è stato decifrato nel titolo e aggiungere uno spoiler al corpo della risposta con il codice esatto
• Lo stesso vale per le risposte sicure (menziona che è sicuro e aggiungi lo spoiler )
• Il codice è considerato sicuro se nessuno lo ha decifrato in 5 giorni dopo la sua pubblicazione e puoi facoltativamente specificarlo nel titolo
• Devi specificare il tuo linguaggio di programmazione
• È necessario specificare il numero di byte
• Devi indicare il meccanismo di arrotondamento nella tua risposta (vedi sotto)

Si può presumere che il risultato sia inferiore a 2 ³² e n sia sempre positivo. Se il risultato è un numero intero, è necessario restituire il valore esatto con o senza un punto decimale; in caso contrario la precisione decimale minima sarà di 3 decimali con qualsiasi meccanismo di arrotondamento di propria scelta, ma può includerne di più. È necessario indicare il meccanismo di arrotondamento nella risposta. Non puoi tornare come frazioni (numeratore, coppie di denominatori - scusa, Bash!)

Esempi:

In -> Out

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

La risposta sicura più breve entro la fine di aprile sarà considerata la vincitrice.

05AB1E, 20 byte - sicuro

Un altro approccio totalmente diverso dalle mie precedenti risposte.

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

Nessun arrotondamento.

L'esempio funziona

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

Non ho dubbi che @Emigna lo spezzerà in un batter d'occhio, ma eh, bisogna provarci! :-D

Soluzione

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

Questo sta usando il fatto che questa sequenza:

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

converge in sqrt (x), e cubicamente veloce (scusate, non ho trovato come formattare le equazioni matematiche in PCG).

Spiegazione dettagliata

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)

Provalo online!

Python 3 , 44 byte ( crackato )

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

Nessun arrotondamento. Precisione in virgola mobile.

MATL , 12 byte ( crackato da @tehtmi )

'Un&0P'/^:+1

Nessun arrotondamento; usa il virgola mobile.

Soluzione prevista (diversa da quella trovata da @tehtmi):

:&+n10U'P'/^

Spiegazione

:&+ % 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 byte ( Cracked by @tehtmi )

 (),.025^^cdfhnnnopprstuu{|}

Nota lo spazio all'inizio. Nessun arrotondamento, ma utilizza numeri in virgola mobile, quindi la precisione è limitata.

Perl, 42 byte (sicuro)

Ci sono 41 byte di codice e -pflag (nessun altro flag).

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

Il risultato non è arrotondato (o piuttosto arrotondato allo stesso punto che Perl avrebbe arrotondato facendo $_ = (sqrt $_) * ($_ ** 2)).

Soluzione:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(senza il \precedente &spoiler - markdown sembra non piacere $seguito da &)
Provalo online!

Spiegazione:

.i44<4}{|~è $_**2*sqrtma con ogni carattere sostituito dal carattere con il suo codice ASCII + 10. (il codice ASCII di $è 36, quindi diventa il .cui codice ASCII è 46, ecc.).
Lo scopo di s/./chr-10+ord$\&/greè quindi annullare questa trasformazione: sostituisce ogni carattere con il carattere con il codice ASCII 10 inferiore. ( chr-10+ord$\&è probabilmente più chiaro come chr(ord($\&)-10)dove chrrestituisce il carattere corrispondente a un codice ASCII e ordrestituisce il codice ASCII corrispondente a un carattere).
infine, evalvaluta questa stringa e quindi calcola il risultato, che viene archiviato $_, che viene implicitamente stampato alla fine grazie a -pflag.

Ottava, 43 byte (sicuro)

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

Questo è uno script che richiede input dalla riga di comando (non è una funzione). È precisione in virgola mobile (quindi nessun arrotondamento).

Soluzione:

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

Spiegazione:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Tutto all'interno della evalchiamata viene valutato input('')^2.5

come?

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

L'aggiunta del primo vettore a questa stringa lo convertirà in un numero intero: lo
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalconverte implicitamente in una stringa e questi numeri sembrano essere: input('')^2.5

C, 50 byte ( crackato da fergusq )

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

Utilizza l'arrotondamento IEEE754 standard. Come notato dalla risposta di fergusq, può richiedere a -lmseconda del compilatore.

Mathematica, 131 byte, non competitiva ?, incrinata

Questo è stato risolto da @ lanlock4 ! Tuttavia, ho ancora punti internet da conferire a qualcuno che trova la soluzione originale, dove tutti i personaggi sono effettivamente necessari ...

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

Questo è inteso come un puzzle. Sebbene tu possa usare i caratteri sopra indicati come desideri, intendo certamente che la risposta segua il modulo

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

dove la prima e la terza riga sono solo un wrapper per rendere legali l'arrotondamento e la visualizzazione (scrive ogni output esattamente con tre cifre decimali, arrotondate), e la seconda riga è la versione confusa delle budella del codice. Output di esempio:

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

(Mathematica è un software non libero, ma esiste una sandbox Wolfram in cui è possibile testare modeste quantità di codice. Ad esempio, tagliare e incollare il codice

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

definisce una funzione, che puoi successivamente chiamare come f@6o f[9], che fa la stessa cosa della versione non decodificata del codice sopra. Quindi questo deve essere davvero non competitivo?)

Swift - 64 byte (sicuro)

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

Nessun arrotondamento e visualizza un .0anche se il risultato è un numero intero.

Haskell, 16 byte ( Cracked by @nimi )

()*...25=eglopxx

Nessun arrotondamento particolare

R, 28 byte ( crackato da @Flounderer )

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

Precisione standard in virgola mobile.

C #, 172 byte ( Cracking di SLuck49 )

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

Questo codice è un programma completo.

Ci sono sette caratteri spaziali all'inizio.

L'input viene letto da STDIN e stampato su STDOUT. Il risultato è in double, nessun arrotondamento fatto.

Codice originale non modificato:

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 byte ( crackato da @IlmariKaronen )

****..22255666=>____

Precisione JavaScript standard.

Python 2, 60 byte ( crackato da @notjagan )

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

Nessun arrotondamento coinvolto. Precisione fino a 10 cifre decimali.

Python 3.6, 59 byte

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

Nessun arrotondamento. Precisione in virgola mobile.

Haskell, 64 byte, ( crackato da Laikoni )

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

Operazioni standard in virgola mobile Haskell.

La mia versione originale è:

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.