Compito: decifrare il codice codificato per moltiplicare la radice quadrata di un numero intero n per il quadrato di esso!

Devi pubblicare un commento nel thread della polizia con un link alla tua fonte di lavoro, menzionando chiaramente che l'hai crackato . Nel titolo della risposta, è necessario includere il collegamento alla risposta originale.

Regole:

• Puoi cambiare l'ordine dei caratteri nella fonte originale.
• Le risposte sicure non possono più essere violate.
• Le altre regole menzionate nel thread della polizia
• Si prega di modificare la risposta che si crack

VINCITORE: Emigna - 10 sottomessi (ha avuto qualche problema nel conteggio)

Menzioni d'onore: Notjagan, Plannapus, TEHTMI

No , 41 byte, questo ragazzo

NOOOOOO?NOOOOOOOOOOO!nnOOOOO
NOOOOOOOO?no

JavaScript (ES7), Neil

_26_=>_26_**6.25**.5

La parte difficile, ovviamente, era capire cosa fare con tutti i personaggi extra. (E anche non pubblicare questa soluzione nella discussione sbagliata, come ho fatto per caso all'inizio. Oopsie ...)

Python, 15 byte, Mr. Xcoder

lambda x:x**2.5

Abbastanza semplice. Lo prende xe lo solleva al 2.5massimo potere.

OCaml, 13 byte, shooqie

fun f->f**2.5

Provalo online!

C ++ (gcc) , 100 byte, Mr. Xcoder

#include<math.h>
#include"iostream"
using namespace std;int main(){float n;cin>>n;cout<<pow(n,2.5);}

Provalo online!

Haskell, Leo

x=exp.(2.5*).log

Una funzione senza punti denominata x. Utilizzo: x 4->32.0

Informare 7 , corvus_192

Fantastico, una voce Inform7. :) Ho appena dovuto provare questo.

Sono abbastanza sicuro che questa sia la soluzione prevista:

R is a room.

To f (n - number): say "[n * n * real square root of n]".

Si noti che questa soluzione funziona solo se compilata con il back-end Glulx, a causa dell'uso della real square root offunzione.

A proposito, le doppie virgolette e le parentesi quadre non sono effettivamente necessarie; solo say n * n * real square root of navrebbe funzionato altrettanto bene. Anche i periodi alla fine dei comandi potrebbero essere omessi; oppure potremmo mantenere il primo periodo e liberarci delle nuove righe invece. Altre parti del codice che potremmo tagliare includono l'articolo "una" prima della "stanza" e gli spazi prima delle parentesi e dopo i due punti. Fortunatamente, poiché abbiamo un paio di parentesi di riserva, possiamo sempre usarle per commentare tutti questi personaggi extra. ;) Quindi anche questa è una soluzione valida:

R is room.To f(n - number):say n * n * real square root of n[
" a . "
]

Per testare questa soluzione in modo interattivo, è conveniente aggiungere al codice qualcosa come il seguente cablaggio di test:

Effing is an action applying to one number.
Understand "f [number]" as effing.
Carry out effing: f the number understood.

Dopo aver compilato ed eseguito il programma, è possibile digitare ad esempio f 4. f 6. f 9. f 25al >prompt e ricevere qualcosa come il seguente output:

Welcome
An Interactive Fiction
Release 1 / Serial number 170404 / Inform 7 build 6L38 (I6/v6.33 lib 6/12N) SD

R

>f 4. f 6. f 9. f 25
32.0
88.18164
243.0
3125.0
>

A proposito, ho appena notato che Inform (o presumibilmente, piuttosto, Glulx) arrotonda l'ultimo punto decimale dell'errore f 6: il valore corretto è molto più vicino a 88.18163 che a 88.18164. Fortunatamente, non penso che ciò influisca sulla correttezza delle soluzioni, soprattutto perché la sfida ha specificato "qualsiasi meccanismo di arrotondamento di tua scelta". :)

Mathematica, Greg Martin

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

Grazie per aver lasciato intatte le cose di arrotondamento!

Spiegazione: #(#)#^(1/(1+1))&@yfa il lavoro principale di moltiplicare yal quadrato, alias y(y), e y'il radice quadrata, y^(1/(1+1)). Il #&@@@{1^(1),-1}bit è solo spazzatura per usare le altre lettere e #&@@estrae il bit utile dalla spazzatura.

MATL , 12 byte, Luis Mendo

10'U&+:'n/^P

Calcola 10/4 = 2.5 con 4 provenienti dalla lunghezza della stringa. Usa questo come esponente. P è una no-op qui.

Python 3, 44 byte, Kyle Gullion

Quelle *s sono stati del tutto fuorviante. Molto intelligente!

lambda i:i**(lambda o,r:o/r)(*map(ord,'i*'))

A causa del set di caratteri piuttosto limitato, sarei molto sorpreso se esistessero altre valide soluzioni oltre alla banale ridenominazione o riordino degli argomenti.

R, Steadybox

y<-function(p)(p^(1/2)*p^2);

sembra essere un anagramma di funny(p1)-tio(^*^)/pc(2)<p2;

Python 2, 60 byte, Anthony Pham

print    (input()**(5.0/(2*5554448893999/5554448893840))-0)

Basato sull'eliminazione dei personaggi tramite la divisione float di Python 2 (impostazione predefinita /tra numeri interi).

C, 50 byte, Dave

double b(float \ufa2d){return pow(\ufa2d,25e-1);%>

Provalo online!

Ciò richiede il -lmflag del compilatore, ma non so come sarebbe possibile risolverlo senza di esso.

R, Flounderer

Questa è una crepa della soluzione a 33 byte di @Flounderer

scan()^(floor(pi)-1/2)-sin(7*0e1)

Uso:

> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 4
2: 
Read 1 item
[1] 32
> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 6
2: 
Read 1 item
[1] 88.18163
> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 9
2: 
Read 1 item
[1] 243
> scan()^(floor(pi)-1/2)-sin(7*0e1)
1: 25
2: 
Read 1 item
[1] 3125

RProgN 2, ATaco

]2^\š*

Apparentemente StackExchange ha bisogno di caratteri extra, quindi eccoti qui.

HODOR, 198, questo ragazzo

Walder
Hodor?!
hodor.
Hodor, Hodor Hodor Hodor Hodor Hodor Hodor Hodor, Hodor Hodor,
hodor,
Hodor, Hodor Hodor Hodor Hodor Hodor Hodor, Hodor Hodor,
Hodor, Hodor Hodor Hodor, hodor!,
HODOR!!
HODOR!!!

Spiegazione:

Start
read input into accumulator
copy accumulator to storage
Do math, option 7(nth root), n=2
swap storage and accumulator
Do math, option 6(nth power), n=2
Do math, option 3(times), storage
output accumulator as a number
end

nota: ho dovuto apportare alcune modifiche all'interprete get per funzionare sulla mia macchina (quello che hai pubblicato non sembra accettare la minuscola h, tra le altre cose)

Inoltre, non ho abbastanza rappresentante per commentare, quindi se qualcuno potesse far sapere a @This Guy, sarei grato

Penso che questo abbia risolto l'errore, il codice ora inizia con Walder invece di Wylis, che aggiunge il byte extra

C #, 172 byte, raznagul

La parte più difficile è stata capire cosa fare con tutti gli avanzi.

using System;using S=System.Console;class PMabddellorttuuv{static void Main(){S.Write(Math.Pow(double.Parse(S.ReadLine()),2.5));Func<double> o;int q=1,M=q*2,b,e;q*=(q*M);}}

EXCEL, 26 byte pajonk

=SQRT(A1)*A1^2/1/ISNA(IP2)

A1 come input IP2 contiene un secondo input con un errore # N / A in questo caso ISNA (IP2) appartiene a 1

Per un ulteriore () possiamo farlo

=SQRT(A1)*A1^2/ISNA(PI(1/2))

Python 3.6, 64 byte, Mr. Xcoder

php38af4r2aoot2srm0itpfpmm0726991i=     (lambda x:x**2.5*1*1/1);

Forse non quello che era previsto, ma funziona;)

$ python3
Python 3.6.1 (default, Apr  4 2017, 09:36:47) 
[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> php38af4r2aoot2srm0itpfpmm0726991i=     (lambda x:x**2.5*1*1/1);
>>> php38af4r2aoot2srm0itpfpmm0726991i(6)
88.18163074019441
>>> php38af4r2aoot2srm0itpfpmm0726991i(4)
32.0
>>> php38af4r2aoot2srm0itpfpmm0726991i(25)
3125.0

Non abbastanza rappresentante per commentare ancora la risposta del thread della polizia, mi spiace ... Gradirei se qualcuno potesse farlo per me, grazie!

Röda , 28 byte, fergusq

f(n){push n^0.5,n^2|product}

Python 2.7, Koishore Roy

s=e=x=y=input()**0.5
print'%.3f'%(y**(5.0))

R, Flounderer

Questa è una fessura della soluzione a 31 byte di @ Flounderer:

`[.`=function(`]`)`]`^`[`(lh,9)

Ok, è stato difficile. Crea una funzione chiamata `[.`. Viene chiamato l'argomento della funzione `]`che viene elevato a 2,5 utilizzando il nono elemento della serie temporale incorporata lh("una serie temporale regolare che fornisce l'ormone luteinizzante in campioni di sangue a intervalli di 10 minuti da una femmina umana, 48 campioni "che viene usato come esempio in uno dei pacchetti base di R). lh[9]è qui sopra sostituito dal suo equivalente `[`(lh, 9). De-offuscata sostituendo fil nome della funzione e nil nome dell'argomento, la funzione diventa quindif=function(n)n^lh[9] .

Uso:

> `[.`=function(`]`)`]`^`[`(lh,9)
> `[.`(4)
[1] 32
> `[.`(6)
[1] 88.18163
> `[.`(9)
[1] 243
> `[.`(25)
[1] 3125

Python 2, 44 byte, Anthony Pham

print int(raw_input())**(0+000000000000.5*5)

Prende input da raw_input, converte in int e aumenta alla potenza 2.5

JavaScript, fəˈnɛtɪk

n=>n**("ggggg".length*2**(-"g".length))// ""((((((()))))))***,-...;;=====>Seeeeegggghhhhhhhhhilllnnnnnnorrrsstttttttttttu{}

Ottiene da 5/2 a 5 volte 2 alla prima potenza negativa, dove 5 e 1 sono stati ricevuti dalla lunghezza delle stringhe. Ho preso la via d'uscita semplice in un certo senso commentando i caratteri estranei.

C #, 112 byte, Jan Ivan

using System;class P{static void Main(){var b=Math.Pow(double.Parse(Console.ReadLine()),2.5);Console.Write(b);}}

05AB1E , 47 byte, Okx

).2555BFHIJJKKKPQRS``„cg…ghi…lsw…x}T…Áöž«‚¹n¹t*

Provalo online!

Fireball , 8 byte, Okx

♥²♥1Z/^*

Spiegazione:

♥²♥1Z/^*
♥²       Push first input squared.
  ♥      Push first input again.
   1Z/   Push 1/2
      ^  First input to the 1/2th
       * Multiply square and root

Non sono sicuro che funzioni. Al momento non ho java sul mio laptop. :(

Haskell , 64 byte, @nimi

product.(<$>(($(succ.cos$0))<$>[(flip<$>flip)id$id,recip])).(**)

Provalo online! È stato divertente. Prima ho scoperto product.(<$>(($succ(cos$0))<$>[id,recip])).(**)che si comporta correttamente e che doveva adattarsi flip flip <$> () $ id .da qualche parte.

R, steadybox

a222=function(s)(s**0.5)*s**2**1

Uso:

> a222=function(s)(s**0.5)*s**2**1
> a222(4)
[1] 32
> a222(6)
[1] 88.18163
> a222(9)
[1] 243
> a222(25)
[1] 3125

05AB1E , 22 byte, P. Manopole

n¹t*qA9¥="'?:@->%#[{!.

Provalo online!

Spiegazione

n      # square of input
   *   # times
 ¹t    # square root of input
    q  # end program

Il resto delle operazioni non viene mai eseguito.
Avremmo potuto farlo anche senza qavere ?dopo il calcolo e sfuggire al segno di uguaglianza, ad esempio con '=.