Uwaga: To jest wątek gliniarzy , w którym należy opublikować kodowany kod. Oto wątek złodziei, w którym należy opublikować złamane źródło i połączyć je z odpowiedzią policjanta.

Zadanie: Napisz najkrótszy bezpieczny program, który zwielokrotnia pierwiastek kwadratowy z liczby całkowitej n przez kwadrat n

To gliniarze i rabusie , więc zasady są następujące:

• W swojej odpowiedzi opublikuj zakodowaną wersję kodu źródłowego (znaki należy pisać w dowolnej kolejności). Wersja kodowana nie powinna działać!
• Możesz przyjmować dane wejściowe w dowolny standardowy sposób, to samo dotyczy wyników. Kodowanie jest zabronione
• Po włamaniu kodu przez złodziei (jeśli tak się stanie), musisz wspomnieć, że Twój kod został złamany w twoim tytule i dodać spoiler do treści odpowiedzi swoim dokładnym kodem
• To samo dotyczy bezpiecznych odpowiedzi (wspomnij, że jest bezpieczny i dodaj spoiler )
• Kod jest uważany za bezpieczny, jeśli nikt go nie złamał w ciągu 5 dni od opublikowania i można go opcjonalnie podać w tytule
• Musisz określić język programowania
• Powinieneś określić liczbę bajtów
• W odpowiedzi należy podać mechanizm zaokrąglania (patrz poniżej)

Możesz założyć, że wynik jest mniejszy niż 2 ^32, a n jest zawsze dodatnie. Jeśli wynikiem jest liczba całkowita, musisz zwrócić dokładną wartość z kropką dziesiętną lub bez; w przeciwnym razie minimalna precyzja dziesiętna będzie wynosić 3 miejsca dziesiętne z dowolnym wybranym mechanizmem zaokrąglania, ale może obejmować więcej. W odpowiedzi należy podać mechanizm zaokrąglania. Nie możesz zwracać jako ułamków (pary licznik, mianownik - przepraszam, Bash!)

Przykłady:

In -> Out

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

Najkrótsza bezpieczna odpowiedź do końca kwietnia zostanie uznana za zwycięzcę.

05AB1E, 20 bajtów - bezpieczny

Kolejne zupełnie inne podejście od moich poprzednich odpowiedzi.

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

Bez zaokrąglania.

Przykład działa

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

Nie mam wątpliwości, że @Emigna rozbije to w mgnieniu oka, ale eh, trzeba spróbować! :-RE

Rozwiązanie

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

Wykorzystuje to fakt, że ta sekwencja:

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

jest zbieżny do sqrt (x) i sześciennie szybki (przepraszam, nie znalazłem sposobu formatowania równań matematycznych w PCG).

Szczegółowe wyjaśnienie

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)

Wypróbuj online!

Python 3 , 44 bajty ( pęknięty )

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

Bez zaokrąglania. Dokładność zmiennoprzecinkowa.

MATL , 12 bajtów ( spolszczenie @tehtmi )

'Un&0P'/^:+1

Bez zaokrąglania; używa zmiennoprzecinkowego.

Zamierzone rozwiązanie (inne niż znalezione przez @tehtmi):

:&+n10U'P'/^

Wyjaśnienie

:&+ % 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 bajtów ( Cracked bytetemi )

 (),.025^^cdfhnnnopprstuu{|}

Zwróć uwagę na spację na początku. Bez zaokrąglania, ale używa liczb zmiennoprzecinkowych, więc precyzja jest ograniczona.

Perl, 42 bajty (bezpieczny)

Jest 41 bajtów kodu i -pflagi (brak innych flag).

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

Wynik nie jest zaokrąglany (a raczej zaokrąglany w górę do tego samego punktu, który Perl wykonałby zaokrąglając w górę $_ = (sqrt $_) * ($_ ** 2)).

Rozwiązanie:

$_=eval".i44<4}{|~"=~s/./chr-10+ord$\&/gre
(bez \wcześniejszego &spoilera - Markdown wydaje się nie lubić, $a potem &)
Wypróbuj online!

Wyjaśnienie:

.i44<4}{|~jest, $_**2*sqrtale z każdym znakiem zastępowanym przez znak z jego kodem ascii + 10. (kod ascii $jest 36, więc staje się .czyim kodem ascii jest 46itd.).
Celem s/./chr-10+ord$\&/grejest zatem cofnięcie tej transformacji: zastępuje ona każdy znak znakiem o kodzie ascii 10 niższym. ( chr-10+ord$\&Prawdopodobnie wyraźniej w chr(ord($\&)-10)którym chrpowraca postać odpowiadającą kodem ASCII i ordzwraca kod ASCII odpowiadającego znakowi).
w końcu evalocenia ten ciąg, a tym samym oblicza wynik, który jest przechowywany $_, który jest domyślnie drukowany na końcu dzięki -pflagi.

Oktawa, 43 bajty (sejf)

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

Jest to skrypt wymagający wprowadzania z wiersza poleceń (nie jest to funkcja). To dokładność zmiennoprzecinkowa (więc nie ma zaokrąglania).

Rozwiązanie:

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

Wyjaśnienie:

eval( <string> ) % Evaluated the string inside the brackets and executes it
Wszystko w evalrozmowie zostaje ocenione na input('')^2.5

Jak?

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

Dodanie pierwszego wektora do tego ciągu spowoduje przekonwertowanie go na wektor całkowity:
[105, 110, 112, 117, 116, 40, 39, 39, 41, 94, 50, 46, 53]

evalniejawnie konwertuje to na ciąg, a liczby te są następujące: input('')^2.5

C, 50 bajtów ( Cracked przez fergusq )

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

Wykorzystuje standardowe zaokrąglanie IEEE754. Jak zauważono w odpowiedzi fergusq, może to wymagać w -lmzależności od kompilatora.

Mathematica, 131 bajtów, niekonkurujący ?, pęknięty

To zostało złamane przez @ lanlock4 ! Nadal jednak mam punkty internetowe, które mogę obdarzyć kogoś, kto znajdzie oryginalne rozwiązanie, w którym wszystkie postacie są rzeczywiście potrzebne ....

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

To jest przeznaczone jako łamigłówka. Chociaż możesz użyć powyższych znaków, jak chcesz, na pewno zamierzam, aby odpowiedź była zgodna z formularzem

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

gdzie pierwsza i trzecia linia są tylko opakowaniem, aby zaokrąglanie i wyświetlanie były legalne (zapisuje każde wyjście dokładnie do trzech miejsc po przecinku, zaokrąglone), a druga linia to kodowana wersja wnętrzności kodu. Przykładowe wyniki:

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

(Mathematica to niewolne oprogramowanie, ale istnieje piaskownica Wolfram, w której można przetestować niewielkie ilości kodu. Na przykład wycinanie i wklejanie kodu

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

definiuje funkcję, którą można następnie wywołać jak f@6lub f[9], która robi to samo, co nieszyfrowana wersja powyższego kodu. Czy to naprawdę musi być niekonkurencyjne?)

Swift - 64 bajty (bezpieczny)

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

Bez zaokrąglania i wyświetla .0nawet, jeśli wynikiem jest liczba całkowita.

Haskell, 16 bajtów ( Cracked bynimi )

()*...25=eglopxx

Bez szczególnego zaokrąglenia

R, 28 bajtów ( Cracked przez @Flounderer )

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

Standardowa dokładność zmiennoprzecinkowa R.

C #, 172 bajtów ( Cracked przez SLuck49 )

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

Ten kod jest pełnym programem.

Na początku jest siedem znaków spacji.

Dane wejściowe są odczytywane ze STDIN i drukowane do STDOUT. Wynik jest w double, nie zaokrąglono.

Niegolfowany kod oryginalny:

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 bajtów ( Cracked przez @IlmariKaronen )

****..22255666=>____

Standardowa precyzja JavaScript.

Python 2, 60 Bytes ( Cracked by @notjagan )

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

Nie wymaga zaokrąglania. Dokładne do 10 cyfr dziesiętnych.

Python 3.6, 59 bajtów

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

Bez zaokrąglania. Dokładność zmiennoprzecinkowa.

Haskell, 64 bajty, ( cracked by Laikoni )

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

Standardowe operacje zmiennoprzecinkowe Haskell.

Moja oryginalna wersja to:

produkt. ((($ succ $ cos $ 0) (flip (**).) [id, przepis])). flip (id)

Fourier , 124 119 bajtów

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

Nie ma białych znaków ani znaków nowej linii.

Pierwiastek kwadratowy jest zaokrąglany do najbliższej liczby całkowitej, ponieważ Fourier nie wydaje się obsługiwać niczego innego niż liczby całkowite (a ponieważ @ATaco uzyskało pozwolenie, mam nadzieję, że jest to w porządku)

naprawiono błąd edycji, jeśli już to łamałeś, poprzedni działał

Uświadomiłem sobie, że źle zrozumiałem część kodu i używałem więcej znaków, niż potrzebowałem

Jeśli coś przeoczyłem, daj mi znać

Poinformuj 7 , 71 bajtów ( Cracked przez @Ilmari Karonen )

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

Kod zawiera 17 spacji i 2 nowe wiersze. Jest to pełny program Infrom 7 definiujący funkcję, która drukuje wynik z dokładnością do 5 miejsc po przecinku.

R, 19 bajtów (Cracked przez @Steadybox)

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

Standardowe zaokrąglenie

R, 33 bajty (Pęknięty przez @plannapus)

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

R, 31 bajtów (Pęknięty przez @plannapus)

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

Oktawa, 30 bajtów (bezpieczny)

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

Trochę prostsze niż moje pierwsze. Nie powinno to być zbyt trudne, ale mam nadzieję, że to zabawna łamigłówka.

Ohm, 11 bajtów

M ⁿ¡D¼½;+1I

Użyj z -cflagą. Wykorzystuje kodowanie CP-437.

OCaml , 13 bajtów ( Cracked by @Dada )

2*fn-5f>f*u .

Bez zaokrąglania (w zakresie IEEE 754).

JavaScript, 123 bajty, Cracked przez notjagan

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

Ten kod jest pełną funkcją

Na początku listy znaków znajduje się jedna spacja

Zaokrąglenie tej odpowiedzi jest precyzją zmiennoprzecinkową dla Javascript, dokładność mieści się w granicach 10 ^ -6 dla każdej odpowiedzi.

Skróciłem się, ponieważ precyzja nie musiała być utrzymywana na tak wysokim poziomie, jak myślałem.

Uświadomiłem sobie, że będzie to o wiele łatwiejsze do rozwiązania niż początkowo to zrobiłem, ale już tam było: P.

Kod początkowy:

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

Metoda Newtona zastosowana 5 razy od najbliższej potęgi 2

Python 3.6 - 52 bajty ( spolszczenie @xnor )

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

Standardowe zaokrąglanie w języku Python

Ruby, 35 bajtów (cracked przez xsot )

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

Bez zaokrąglania. Dokładność zmiennoprzecinkowa.

05AB1E , 47 bajtów

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

Nie zaokrągla, używa dokładności zmiennoprzecinkowej.

CJam, 8 bajtów ( Cracked by E n mig m na )

WYdYl##+

Bez zaokrąglania. Wykorzystuje podwójną precyzję.

R, 32 bajty ( Pęknięty przez @plannapus )

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

Standardowa dokładność zmiennoprzecinkowa.

Excel, 26 bajtów

=(())*//11122AAAIINPQRSST^

Bez zaokrąglania.

Uwaga: Ponieważ Excel jest oprogramowaniem płatnym, działa to również w bezpłatnym pakiecie LibreOffice

RProgN 2 , 6 bajtów ( Cracked przez @notjagan )

š2]^*\

Bez zaokrąglania, wyświetla wiele miejsc po przecinku. Nie wyświetla żadnego dla rozwiązania liczb całkowitych.