Note: Ceci est le fil des flics , où l'on devrait poster le code brouillé. Voici le fil de discussion des voleurs où la source fissurée doit être publiée et liée à la réponse du policier.

Tâche: Écris le programme sûr le plus court qui multiplie la racine carrée d’un entier n par le carré de n

C'est des flics-and-robbers , alors les règles sont les suivantes:

• Dans votre réponse, postez une version brouillée de votre code source (les caractères doivent être écrits dans n’importe quel ordre). La version brouillée ne devrait pas fonctionner!
• Vous pouvez prendre une entrée de n'importe quelle manière standard, il en va de même pour la sortie. Le codage en dur est interdit
• Une fois le code craqué par les voleurs (si cela se produit), vous devez mentionner que votre code a été déchiffré dans votre titre et ajouter un spoiler au corps de votre réponse avec votre code exact.
• Il en va de même pour les réponses sûres (mentionnez que c'est sûr et ajoutez le spoiler )
• Le code est considéré comme sûr si personne ne l'a déchiffré dans les 5 jours suivant sa publication et vous pouvez éventuellement le spécifier dans le titre.
• Vous devez spécifier votre langage de programmation
• Vous devez spécifier votre nombre d'octets
• Vous devez indiquer le mécanisme d'arrondi dans votre réponse (voir ci-dessous)

Vous pouvez supposer que le résultat est inférieur à 2 ³² et que n est toujours positif. Si le résultat est un entier, vous devez renvoyer la valeur exacte avec ou sans point décimal. sinon, la précision décimale minimale sera de 3 décimales avec le mécanisme d'arrondi de votre choix, mais vous pouvez en inclure davantage. Vous devez indiquer le mécanisme d'arrondi dans votre réponse. Vous n'êtes pas autorisé à retourner sous forme de fractions (numérateur, paires de dénominateurs - désolé, Bash!)

Exemples:

In -> Out

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

La réponse la plus courte et sûre d’ici fin avril sera considérée comme gagnante.

05AB1E, 20 octets - sûr

Une autre approche totalement différente de mes réponses précédentes.

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

Pas d'arrondi.

Exemple fonctionne

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

Je ne doute pas que @Emigna va le résoudre en un tour de main, mais eh, il faut essayer! :-RÉ

Solution

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

Ceci utilise le fait que cette séquence:

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

converge vers sqrt (x) et rapidement cubiquement (désolé, je n’ai pas trouvé comment formater les équations mathématiques dans PCG).

Explication détaillée

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)

Essayez-le en ligne!

Python 3 , 44 octets ( fissuré) )

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

Pas d'arrondi. Précision en virgule flottante.

MATL , 12 octets ( fissuré par @tehtmi )

'Un&0P'/^:+1

Pas d'arrondi; utilise la virgule flottante.

Solution envisagée (différente de celle trouvée par @tehtmi):

:&+n10U'P'/^

Explication

:&+ % 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 ( fissuré par @tehtmi )

 (),.025^^cdfhnnnopprstuu{|}

Notez l'espace au début. Pas d'arrondi, mais il utilise des nombres à virgule flottante, ce qui limite la précision.

Perl, 42 octets (sûr)

Il y a 41 octets de code et d' -pindicateur (aucun autre indicateur).

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

Le résultat n'est pas arrondi (ou plutôt arrondi au même point que Perl aurait arrondi en faisant $_ = (sqrt $_) * ($_ ** 2) ).

Solution:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(sans le - le spoiler de démarque \avant &semble ne pas aimer $suivi de &)
Essayez-le en ligne!

Explication:

.i44<4}{|~is, $_**2*sqrtmais chaque caractère est remplacé par le caractère avec son code ascii + 10. (code ascii de $is 36, il devient donc .le code ascii 46, etc.).
Le but de s/./chr-10+ord$\&/greest alors d'annuler cette transformation: il remplace chaque caractère par le caractère avec le code ASCII 10 inférieur. ( chr-10+ord$\&est probablement plus clair car chr(ord($\&)-10)where chrrenvoie le caractère correspondant à un code ascii et ordrenvoie le code ascii correspondant à un caractère).
enfin, evalévalue cette chaîne et calcule donc le résultat, qui est stocké dans $_, qui est implicitement imprimé à la fin grâce à -pflag.

Octave, 43 octets (sûr)

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

Ceci est un script qui nécessite une entrée à partir de la ligne de commande (ce n'est pas une fonction). C'est une précision en virgule flottante (donc pas d'arrondi).

Solution:

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

Explication:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Tout dans l' evalappel est évalué à input('')^2.5

Comment?

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

Ajouter le premier vecteur à cette chaîne le convertira en vecteur entier:
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalconvertit implicitement cela en chaîne, et ces nombres se trouvent être: input('')^2.5

C, 50 octets ( fissuré par fergusq )

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

Utilise l'arrondi IEEE754 standard. Comme indiqué par la réponse de fergusq, peut nécessiter en -lmfonction de votre compilateur.

Mathematica, 131 octets, non en concurrence?, Fissuré

Cela a été craqué par @ lanlock4 ! Cependant, il me reste des points Internet à attribuer à quelqu'un qui trouve la solution originale, où tous les personnages sont réellement nécessaires ....

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

Ceci est conçu comme un casse-tête. Bien que vous puissiez utiliser les caractères ci-dessus comme bon vous semble, j’ai bien l'intention que la réponse suive le formulaire

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

où les première et troisième lignes ne sont qu'un emballage pour rendre les arrondis et les afficher légaux (toutes les sorties sont écrites avec exactement trois décimales, arrondies), et la deuxième ligne est la version brouillée des entrailles du code. Exemples de sortie:

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

(Mathematica est un logiciel non-libre, mais il existe un bac à sable Wolfram où il est possible de tester de petites quantités de code. Par exemple, couper et coller le code

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

définit une fonction, que vous pouvez ensuite appeler comme f@6ou f[9], et qui fait la même chose que la version non cryptée du code ci-dessus. Alors, est-ce que cela doit vraiment être non compétitif?)

Swift - 64 octets (sûr)

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

Aucun arrondi, et affiche .0même si le résultat est un entier.

Haskell, 16 octets ( fissuré par @nimi )

()*...25=eglopxx

Aucun arrondi particulier

R, 28 octets ( fissuré par @Flounderer )

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

Précision standard en virgule flottante.

C #, 172 octets ( fissuré par SLuck49 )

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

Ce code est un programme complet.

Il y a sept espaces au début.

L'entrée est lue sous STDIN et imprimée sur STDOUT. Le résultat est dans double, pas d'arrondi.

Code original non-golfé:

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.