Hinweis: Dies ist der Thread der Polizei , in dem man den verschlüsselten Code posten sollte. Hier ist der Räuber-Thread, in dem die geknackte Quelle veröffentlicht und mit der Antwort des Polizisten verknüpft werden sollte.

Aufgabe: Schreiben Sie das kürzeste sichere Programm, das die Quadratwurzel einer ganzen Zahl n mit dem Quadrat von n multipliziert

Das sind Bullen und Räuber , daher gelten folgende Regeln:

• Schreiben Sie in Ihrer Antwort eine verschlüsselte Version Ihres Quellcodes (die Zeichen sollten in beliebiger Reihenfolge geschrieben werden). Die verschlüsselte Version sollte nicht funktionieren!
• Sie können Eingaben auf jede übliche Art und Weise vornehmen. Gleiches gilt für die Ausgabe. Hardcoding ist verboten
• Nachdem der Code von den Räubern geknackt wurde (falls dies passiert), müssen Sie erwähnen, dass Ihr Code in Ihrem Titel geknackt wurde, und einen Spoiler mit Ihrem genauen Code in den Körper Ihrer Antwort einfügen
• Das gleiche gilt für sichere Antworten (erwähne, dass es sicher ist und füge den Spoiler hinzu )
• Der Code gilt als sicher, wenn ihn innerhalb von 5 Tagen nach seiner Veröffentlichung niemand geknackt hat, und Sie können dies optional im Titel angeben
• Sie müssen Ihre Programmiersprache angeben
• Sie sollten Ihre Byteanzahl angeben
• Sie müssen den Rundungsmechanismus in Ihrer Antwort angeben (siehe unten)

Sie können davon ausgehen, dass das Ergebnis niedriger als 2 ^{32 ist} und n immer positiv ist. Wenn das Ergebnis eine Ganzzahl ist, müssen Sie den genauen Wert mit oder ohne Dezimalstelle zurückgeben. Andernfalls beträgt die minimale Dezimalgenauigkeit 3 ​​Dezimalstellen mit einem beliebigen Rundungsmechanismus, sie kann jedoch auch mehr enthalten. Sie müssen den Rundungsmechanismus in Ihrer Antwort angeben. Sie dürfen nicht als Bruchteile zurückgeben (Zähler-, Nennerpaare - sorry, Bash!)

Beispiele:

In -> Out

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

Die kürzeste sichere Antwort bis Ende April wird als Gewinner gewertet.

05AB1E, 20 Byte - sicher

Ein ganz anderer Ansatz als meine vorherigen Antworten.

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

Keine Rundung.

Beispiel läuft

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

Ich habe keinen Zweifel, @Emigna wird es im Handumdrehen knacken, aber eh, man muss es versuchen! :-D

Lösung

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

Dies beruht auf der Tatsache, dass diese Sequenz:

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

Konvergiert zu sqrt (x) und ist dabei kubisch schnell (ich habe leider nicht herausgefunden, wie man mathematische Gleichungen in PCG formatiert).

Ausführliche Erklärung

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)

Probieren Sie es online!

Python 3 , 44 Bytes ( geknackt )

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

Keine Rundung. Fließkomma-Genauigkeit.

MATL , 12 Bytes ( geknackt von @tehtmi )

'Un&0P'/^:+1

Keine Rundung; verwendet Gleitkomma.

Geplante Lösung (anders als von @tehtmi gefunden):

:&+n10U'P'/^

Erläuterung

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

 (),.025^^cdfhnnnopprstuu{|}

Beachten Sie das Leerzeichen am Anfang. Keine Rundung, aber es werden Gleitkommazahlen verwendet, sodass die Genauigkeit begrenzt ist.

Perl, 42 Bytes (sicher)

Es gibt 41 Byte Code und -pFlag (keine anderen Flags).

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

Das Ergebnis wird nicht gerundet (oder vielmehr auf den gleichen Punkt aufgerundet, den Perl damit aufgerundet hätte $_ = (sqrt $_) * ($_ ** 2)).

Lösung:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(ohne den \vor dem &- markdown stehenden Spoiler scheint das nicht zu gefallen, $gefolgt von &)
Probier es online aus!

Erläuterung:

.i44<4}{|~wird $_**2*sqrtaber mit jedem Zeichen durch das Zeichen mit seinem ASCII-Code + 10 ersetzt (ASCII-Code von $ist 36, also wird es .dessen ASCII-Code 46usw.).
Der Zweck von s/./chr-10+ord$\&/greist dann, diese Transformation rückgängig zu machen: Es ersetzt jedes Zeichen durch das Zeichen mit dem ASCII-Code 10 niedriger. ( chr-10+ord$\&Ist wahrscheinlich klarer, als chr(ord($\&)-10)wenn chrdas Zeichen, das einem ASCII-Code entspricht, und ordder ASCII-Code, der einem Zeichen entspricht, zurückgegeben wird.) wertet
schließlich evaldiesen String aus und berechnet so das Ergebnis, das in gespeichert ist $_, das am Ende dank -pflag implizit gedruckt wird .

Oktave, 43 Bytes (Sicher)

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

Dies ist ein Skript, das Eingaben über die Befehlszeile erfordert (es ist keine Funktion). Es ist Gleitkommagenauigkeit (also keine Rundung).

Lösung:

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

Erläuterung:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Alles innerhalb des evalAnrufs wird wie ausgewertet input('')^2.5

?

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

Wenn Sie den ersten Vektor zu dieser Zeichenfolge hinzufügen, wird er in den ganzzahligen Vektor
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalkonvertiert. Dies wird implizit in eine Zeichenfolge konvertiert, und diese Zahlen lauten zufällig: input('')^2.5

C, 50 Bytes ( geknackt von Fergusq )

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

Verwendet die Standardrundung nach IEEE754. Wie in der Antwort von fergusq angegeben, kann dies -lmabhängig von Ihrem Compiler erforderlich sein .

Mathematica, 131 Bytes, nicht konkurrierend ?, geknackt

Dies wurde von @ lanlock4 geknackt ! Ich habe jedoch immer noch Internetpunkte, mit denen ich jemanden beschenken kann, der die ursprüngliche Lösung findet, bei der alle Charaktere tatsächlich benötigt werden ....

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

Dies ist als Puzzle gedacht. Obwohl Sie die obigen Zeichen verwenden können, wie Sie möchten, möchte ich, dass die Antwort dem Formular folgt

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

Die erste und dritte Zeile sind nur ein Wrapper, um die Rundung und Anzeige zu ermöglichen (jede Ausgabe wird auf genau drei Dezimalstellen gerundet), und die zweite Zeile ist die verschlüsselte Version der Eingeweide des Codes. Beispielausgaben:

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

(Mathematica ist keine freie Software, aber es gibt eine Wolfram-Sandbox, in der es möglich ist, bescheidene Codemengen zu testen. Zum Beispiel das Ausschneiden und Einfügen des Codes

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

definiert eine Funktion, die Sie anschließend wie f@6oder aufrufen können f[9]und die das Gleiche tut wie die unverschlüsselte Version des obigen Codes. Muss das wirklich konkurrenzlos sein?)

Swift - 64 Bytes (sicher)

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

Keine Rundung und zeigt eine .0Gerade an, wenn das Ergebnis eine Ganzzahl ist.

Haskell, 16 Bytes ( Gebrochen von @nimi )

()*...25=eglopxx

Keine besondere Rundung

R, 28 Bytes ( Gebrochen von @Flounderer )

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

Standard R Fließkommagenauigkeit.

C #, 172 Bytes ( geknackt von SLuck49 )

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

Dieser Code ist ein vollständiges Programm.

Am Anfang stehen sieben Leerzeichen.

Die Eingabe wird von STDIN gelesen und auf STDOUT gedruckt. Das Ergebnis ist in double, keine Rundung erfolgt.

Originalcode 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 ( Gebrochen von @IlmariKaronen )

****..22255666=>____

Standardmäßige JavaScript-Genauigkeit.

Python 2, 60 Bytes ( Gebrochen von @notjagan )

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

Keine Rundung. Genauigkeit von bis zu 10 Dezimalstellen.

Python 3.6, 59 Bytes

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

Keine Rundung. Fließkomma-Genauigkeit.

Haskell, 64 Bytes ( geknackt von Laikoni )

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

Standard Haskell Gleitkommaoperationen.

Meine ursprüngliche Version ist:

Produkt. ((($ succ $ cos $ 0) (Flip (**).) [ID, Rezept])). Flip (ID)

Fourier , 124 119 Bytes

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

Es gibt keine Leerzeichen oder Zeilenumbrüche.

Die Quadratwurzel wird auf die nächste ganze Zahl gerundet, da Fourier nur Ganzzahlen zu verarbeiten scheint (und da @ATaco die Erlaubnis erhalten hat, hoffe ich, dass dies in Ordnung ist).

Behebung eines Bearbeitungsfehlers. Wenn Sie dies bereits geknackt haben, war das vorherige funktionsfähig

Es wurde mir klar, dass ich einen Teil des Codes falsch verstanden hatte und mehr Zeichen verwendete, als ich brauchte

Wenn ich etwas verpasst habe, lass es mich wissen

Informiere 7 , 71 Bytes ( Gebrochen von @Ilmari Karonen )

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

Der Code enthält 17 Leerzeichen und 2 neue Zeilen. Dies ist ein vollständiges Infrom 7-Programm, das eine Funktion definiert, die das Ergebnis mit einer Genauigkeit von 5 Dezimalstellen ausgibt.

R, 19 Bytes (Gebrochen von @Steadybox)

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

Standardrundung

R, 33 Bytes (geknackt von @plannapus)

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

R, 31 Bytes (geknackt von @plannapus)

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

Oktave, 30 Bytes (Sicher)

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

Ein bisschen einfacher als meine erste. Sollte nicht zu schwer sein, aber es ist hoffentlich ein lustiges Puzzle.

Ohm, 11 Bytes

M ⁿ¡D¼½;+1I

Verwenden Sie mit -cFlagge. Verwendet CP-437-Codierung.

OCaml , 13 Bytes ( geknackt von @Dada )

2*fn-5f>f*u .

Keine Rundung (im Rahmen von IEEE 754).

Javascript, 123 Bytes, Gebrochen von notjagan

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

Dieser Code ist eine vollständige Funktion

Ganz am Anfang der Zeichenliste befindet sich ein Leerzeichen

Die Rundung dieser Antwort ist die Gleitkomma-Genauigkeit für Javascript, die Genauigkeit liegt bei jeder Antwort innerhalb von 10 ^ -6.

Wurde kürzer, weil die Präzision nicht so hoch gehalten werden musste, wie ich dachte.

Ich hatte erkannt, dass es viel einfacher zu lösen sein würde, als ich es ursprünglich gemacht hatte, aber es war bereits da: P

Anfangscode:

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

Newton-Methode, angewendet 5 mal ab der nächsten Potenz von 2

Python 3.6 - 52 Bytes ( geknackt von @xnor )

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

Standard-Python-Rundung

Ruby, 35 Bytes (geknackt von xsot )

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

Keine Rundung. Fließkomma-Genauigkeit.

05AB1E , 47 Bytes

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

Rundet nicht, verwendet Gleitkomma-Genauigkeit.

CJam, 8 Bytes ( geknackt von E n mig m na )

WYdYl##+

Keine Rundung. Verwendet doppelte Präzision.

R, 32 Bytes ( geknackt von @plannapus )

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

Standard-Gleitkommagenauigkeit.

Excel, 26 Bytes

=(())*//11122AAAIINPQRSST^

Keine Rundung.

Hinweis: Da Excel eine kostenpflichtige Software ist, funktioniert dies auch im kostenlosen LibreOffice

RProgN 2 , 6 Bytes ( geknackt von @notjagan )

š2]^*\

Keine Rundung, zeigt viele Nachkommastellen an. Zeigt für eine ganzzahlige Lösung keine an.