È necessario creare un poliglotta che emetta il quadrato dell'input in una lingua e la radice quadrata dell'input in un'altra lingua. Vince la risposta più breve in byte!
Devi avere una precisione di almeno 3 cifre decimali e l'input sarà sempre un float positivo.
Risposte:
U
Radice quadrata in Jolf, piazza in MATL.
Provalo online! (MATL)
Prova il codice Jolf. Funziona solo su Firefox.
Questi sono entrambi 1 byte, poiché MATL e Jolf usano entrambi codici ASCII / ASCII estesi, quindi tutti i comandi sono 1 byte.
#include<math.h>
float f(float n){auto p=.5;return pow(n,2-p*3);}
Risposta originale:
#include<math.h>
float f(float n){return pow(n,sizeof('-')-1?2:.5);}
Per entrambe le versioni, C produce n^2e C ++ produce sqrt(n).
autosignifica "allocare nello stack". La parola chiave è abbastanza inutile perché è comunque quella predefinita, quindi C ++ l'ha riproposta per significare qualcos'altro. In C, tuttavia, non esprime alcuna opinione sul tipo di p(è una classe di archiviazione, non un tipo), quindi conta come un intvalore predefinito (questo intcomportamento predefinito è sconsigliato al giorno d'oggi, e probabilmente esiste solo perché alcuni dei predecessori di C non avevano affatto tipi di dati, ma i compilatori lo capiscono ancora). E, naturalmente, (int)0.5è 0.
n^2.
lambda n:n**(1/2or 2)Python 2.x produce n^2, Python 3.x produce sqrt(n).
2 byte salvati grazie a @Dennis!
or?
/fa divisione intera ( 1/2==0). In Py3, fa divisione in virgola mobile ( 1/2==0.5). 0È falso.
*.
2sable calcola il quadrato. Provalo online!
La gelatina calcola la radice quadrata. Provalo online!
* Read the input twice and compute the product of both copies.
This pushes the square of the input.
. Unrecognized token (ignored).
. Numeric literal; yield 0.5.
* Raise the input to the power 0.5.
This yields the square root.
#/*
lambda n:n**.5;'''*/
float a(i){return i*i;}//'''Python: provalo online!
Funziona usando i commenti per poliglotta. Il resto è piuttosto esplicativo.
Prima volta che usi C!
return 0;dalla fine - C99 contiene un ritorno implicito di 0 in main()particolare. Fonte
stdio.hin quel caso?
Emette il quadrato in Ohm, la radice quadrata in Jelly.
Ohm e Jelly usano diverse codepage a byte singolo, quindi il programma apparirà in modo diverso in ogni codifica.
xxd hexdump del programma:
00000000: fd7f 0a ...
Usando la tabella codici di Jelly, appare così:
’
½
Jelly prende la linea più in basso per essere il suo collegamento principale e ignora gli altri collegamenti a meno che non venga chiamato specificamente. Quindi qui fa solo la radice quadrata ( ½) e la genera implicitamente.
Utilizzando la tabella codici di Ohm (CP437), appare così:
²⌂◙
²è la funzione quadrata ⌂e ◙sono entrambi indefiniti, quindi il programma quadra in modo implicito l'input letto in modo implicito e lo genera implicitamente.
½un byte, a cosa serve la ²mappa? È solo spazzatura che è ancora ignorata? E viceversa per Ohm? Quindi sembrerebbe essere di 2 byte.
²in Ohm si trovi al punto di codice 5. Il punto di codice 5 in Jelly è %e non fa nulla, quindi non importa quale sia la prima riga. Supponiamo che ½in Jelly sia a 27 e che il punto di codice 27 in Ohm sia Je non faccia nulla, quindi non importa quale sia la seconda riga. Pertanto, se si dispone di un file di 00000101<newline>00011011, è di 3 byte. Immagino che l'unico problema sia se la newline si trova in una posizione diversa nelle pagine di codice.
float f(float n){return n//*
/sqrt(n)//*/1*n
;}Richiede -lmbandiera (+3)
C89 produce n^2, C99 produce sqrt(n). Per testare in C89, provalo online!
Fare in modo che C89 esegua la sqrtversione dovrebbe richiedere meno codice, ma insiste nel dichiarare implicitamente la sqrtfunzione con ints, quindi questo è il migliore che potrei gestire.
@(x)x^(2-3*any(version>60)/2)
Questo genera il quadrato in Octave e la radice quadrata in MATLAB.
Spiegazione:
La sintassi è ovviamente identica in MATLAB e Octave (almeno per questo piccolo pezzo di codice).
Questo crea una funzione anonima:
@(x) % Take x as input
x^( ) % Raise x to the power of ...
version % Returns the version number
% 4.2.0 in Octave,
% '9.2.0.538062 (R2017a)' in MATLAB
version>60 % 'R' is larger than 60. All others are smaller
3*any(version>60)/2 % Checks if there is an 'R' and multiplies it by 1.5 if it is.
2-3*any(version>60) % 2-1.5*(is there an 'R')
sqr(x)
Radice quadrata in Basic e quadrata in Delphi.
È possibile utilizzare un debugger per ispezionare l'espressione, soddisfacendo così tutti i requisiti di output!
x? Non puoi presumere che sia stato salvato su un valore. Ma potresti effettivamente essere in grado di rimuovere (x)e etichettarlo come restituzione di una funzione.
I seguenti byte compongono il programma:
FD B9 74
05AB1E calcola la radice quadrata, i quadrati della palla di fuoco.
Spiegazione (05AB1E - ý¹t):
ý Pushes an empty string to the stack (not entirely sure why)
¹ Push first input
t Square root
Spiegazione (Fireball - ²╣t):
² Square input
╣ Unassigned
t Unassigned
A volte, aiuta ad avere un linguaggio incompleto;)
Questo è stato in realtà più impegnativo di quanto mi aspettassi! Sono abbastanza sorpreso di quanto sia lungo il mio codice.
eval(['alert((_=prompt())*_)','echo$argv[1]**.5'][+![]]);Come funziona?
Funziona selezionando il codice da eseguire, dall'array.
Il rilevamento di PHP e JavaScript viene effettuato con +![].
In PHP, [](array vuoto) è un valore di falsità, mentre in JavaScript è un valore di verità (gli oggetti (tranne null) sono sempre veri, persino new Boolean(false)è vero!).
Ma devo ottenerlo in un valore numerico, quindi uso solo un not( !) e lo converto in intero (con il +).
Ora, PHP produce il valore 1, mentre JavaScript produce 0.
Posizionare il codice all'interno di un array, in quegli indici, ci permetterà di selezionare il codice giusto per la lingua desiderata.
Questo può essere usato come [JS,PHP][+![]], per ottenere il codice della lingua giusta.
Sui precedenti poliglotti, ho usato '\0'=="\0", che è truein JavaScript (poiché \0viene analizzato come byte NULL) e falsein PHP ( '\0'non verrà analizzato come byte NULL, confrontando la stringa letterale \0con il byte NULL).
Sono felice di essere riuscito a ridurre questo controllo a +!'0'.
Sono ancora più felice di @rckd , che lo ha ridotto alla versione attuale!
Da lì in poi, è semplicemente evalil codice richiesto.
PHP
PHP eseguirà echo$argv[1]**.5(equivalente a echo sqrt($argv[1]);, radice quadrata il numero), ricevendo il valore dal secondo argomento e lo visualizza nell'output standard.
JavaScript
Viene eseguito JavaScript alert((_=prompt())*_), che visualizza il numero al quadrato in un alert.
Grazie a @rckd per aver salvato 1 byte e @ user59178 per aver salvato 3 byte!
echo$argv[1]**.5invece diecho sqrt($argv[1])
nqƓ½
nq # Ignored by Jelly, push n**2 in 05AB1E then quit.
Ɠ½ # Ignored by 05AB1E due to quit, push sqroot of input in Jelly.
Qualcun altro ha fatto un buon punto, immagino poiché i caratteri UTF-8 non condividono la stessa operazione tra le pagine di codice che tecnicamente sono 2 byte ciascuno da codificare. Tuttavia, quando si guarda questo in termini di discarica esadecimale:
6e 71 93 0a
Nella codifica CP1252 di 05AB1E questo si traduce in:
nq“\n
Significa che emetterà comunque il quadrato ed uscirà, ignorando il resto. Quando questi byte sono codificati usando la tabella codici di Jelly:
nqƓ½
Quale è il codice originale previsto, quando eseguito, si traduce nel risultato desiderato di prendere l'input e prendere il sqrt.
Ɠe ½richiedono due byte per essere codificati. Tuttavia, la sequenza di byte 6e 71 93 0a( nqƓ½per Jelly, nq“\nper CP-1252) dovrebbe funzionare in entrambe le lingue.
½trovarsi su entrambe le code-page non consente di contare come un singolo perché sono diverse operazioni presumo? Sono ancora confuso sull'intera faccenda della code page.
6e 71 93 0aquindi non c'è "teoricamente" di rivendicare 4 byte. Richiedi solo 4 byte. Accade così che nella codifica standard di 05AB1E legga una cosa che fa quello che vuoi, mentre nella codifica standard di Jelly ne legge un'altra che fa quello che vuoi. Per inciso, solo perché 2 codifiche possono codificare lo stesso personaggio non significa che quel personaggio sarà lo stesso in entrambi. Pensa solo a codifiche come un cifrario numerico con una tabella di ricerca già condivisa e, si spera, che ti darà un buon modello mentale iniziale.
ld_*GX^!
Calcola il quadrato in CJam ( provalo online! ) E la radice quadrata in MATL ( provalo online! ).
ld e# Read input line and interpret as a double
_ e# Duplicate
* e# Multiply. Pops the input number twice, pushes its square
G e# Push 16
X e# Push 1
^ e# Bitwise XOR. Pops 16 and 1, and pushes 17
! e# Negate. Pops 17, pushes 0
e# Implicitly display. This prints the squared input with decimals,
e# immediately followed by the 0 coming from the negate operation
e# Even if the square of the input number is an integer, say 5,
e# it is displayed as 5.0, so including an extra 0 always gives a
e# correct result
l % Push 1. This is a number or equivalently a 1×1 array
d % Consecutive differences. Pops 1, pushes [] (empty array)
_ % Negate (element-wise). This leaves [] as is
* % Implicitly input a number and push it. Multiply (element-wise):
% pops [] and the input number, pushes []
G % Push input number again
X^ % Square root. Pops number, pushes its square root
! % Transpose. For a number (1×1 array) this does nothing
% Implicitly display. The stack contains [] and the result; but
% [] is not displayed at all
( """ )
fsqrt
\ """);lambda n:n*nProvalo online: Python 2 (quadrato) | Forth (sqrt)
Ciò restituisce una funzione anonima in Python e una funzione integrata fsqrtin Forth. Python può avere una funzione denominata fper 2 byte in più mettendo f=davanti al lambda.
Il programma Forth prende letteralmente un virgola mobile , che in Forth deve essere scritto in notazione scientifica. Pi troncato con 3 cifre decimali ( 3.141) verrebbe scritto in questo modo:
3141e-3
f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)
Restituisce il quadrato dell'input in ES7 e la radice quadrata in ES6. Abbastanza difficile da testare, a meno che tu non abbia un browser più vecchio che supporti ES6 ma non ES7.
f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)
console.log(f(4));ECHO"$argv[1]"**2;#];rdmq
Calcola il quadrato in PHP e la radice quadrata in CJam. Deve essere eseguito utilizzando -rin PHP.
Solleva il primo argomento della riga di comando ( $argv[1]) alla potenza 2 e lo emette. Qui $argv[1]viene effettivamente inserito come una variabile inline in una stringa, che viene lanciata su un numero prima di eseguire l'espiazione. Questo perché vnon è un'istruzione valida in CJam e causerà errori durante l'analisi, ma inserirla in una stringa non causerà alcun problema.
# inizia un commento, quindi tutto ciò che viene ignorato.
La prima parte del codice, ECHO"$argv[1]"**2;#spinge un sacco di valori e fa un mucchio di operazioni, tutte completamente inutili. L'unica cosa importante è che non causano errori, perché subito dopo è ];, che avvolge l'intero stack in un array e lo scarta.
Dopodiché, legge un doppio da input ( rd), ottiene la sua radice quadrata ( mq) e lo genera implicitamente.
;float f(float x){return sqrt(x);}char*
F="_this^2";
In uno script OFP, un punto e virgola all'inizio di una riga rende tale riga un commento, mentre a C non interessa il punto e virgola aggiuntivo.
C:
Linguaggio di scripting OFP:
Salva come init.sqsnella cartella della missione, quindi chiamalo con hint format["%1", 2 call F].
Risultato: 
Lingue 2D!
/&:*.@
>in:o#p;
/&:*.@
/ divide top two (no-op)
& read decimal input
: duplicate
* square
. output
@ terminate
/ mirror up, then right
>in:o#p;
i read line of input
n cast to number
:o# square root
p print
; terminate
Amico, mi sto davvero divertendo con la struttura dei collegamenti Jelly.
:*n;
½
Calcola il quadrato in> <> e la radice quadrata in Gelatina .
-v, secondo me, è in linea con la [risposta più votata [( codegolf.meta.stackexchange.com/a/11431/44874 ) su una meta query che gestisce questo caso. L' ><>interprete ne ha bisogno -ve questo è per questo la più semplice possibile invocazione.
0//1or exec("function=lambda a:(lambda b:a);x=0")
y=2//2/2
f=(function(x)(x**y))//1 or(lambda x:x**y)Radice quadrata in JS, quadrata in Python.
Funziona su Firefox (testato su FF 52) e richiede (function(x) x)(42) === 42una sintassi valida. Richiede anche ES7 per l' **operatore.
x=>x**yinvece? O Python lo soffocerà?
functionnon è una parola chiave, è un identificatore valido. Quindi ho appena assegnato una funzione noop ad essa (all'interno execdell'istruzione).
Aggiornamento: devo ammettere la sconfitta. La risposta bash / sh di Digital Trauma è molto più elegante di questa.
bc -l<<<"sqrt($1^(($(kill -l|wc -l)*3-3)/7+1))"bash produce n^2, sh produce sqrt(n).
bcè necessario solo per sqrtpoter essere calcolato. La differenza di comportamento è tra bash e sh.
OK, tecnicamente lo "sh" che sto usando è ancora bash, ma bash in modalità "POSIX" (che succede se invochi /bin/shinvece che /bin/bashsu sistemi dove /bin/shè un alias per bash). Se questo è il caso sul tuo sistema, puoi provare con:
/bin/bash prog.sh 4
/bin/sh prog.sh 4Questo si basa su una delle differenze spiegate qui: https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
kill -l(elenca i segnali possibili; non cambia nulla) in bashe sh. È una delle molte differenze che puoi trovare qui: gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
input a
?a^2'^.25
In QBasic , prende un numero e stampa quel numero al quadrato. Il resto del codice viene ignorato perché QBasic lo vede come un commento ( ').
QBIC utilizza la stessa istruzione di input. Quindi ha continuato a stampare lo stesso numero al quadrato, quindi elevato alla potenza di un quarto, effettuando il rooting efficacemente due volte. Questo perché 'viene visto come un codice letterale: codice QBasic puro non analizzato da QBIC.
EDIT: è un byte più breve per invertire le operazioni.
RTa
²
Jelly inizia l'esecuzione nella parte inferiore del codice (il suo "collegamento principale") e vede se ha bisogno di qualcosa di più alto: vede il comando quadrare e si occupa in modo implicito dell'input e dell'output.
Pip esegue la riga superiore, quadrando la var (implicitamente letta dalla riga cmd) e la stampa implicitamente. La linea di fondo viene ignorata.
PRTaVS.
Ottieni il quadrato di un numero in Wolfram Language e ottieni la radice quadrata in PHP;
n^2
echo sqrt(_GET["n"]);
La prima riga è Wolfram Language. Innanzitutto, sei tu a cambiare n nella barra di ricerca in Wolfram Alpha, quindi anche il codice è l'input. Quindi genererà la risposta premendo Invio
n^2
La seconda riga è PHP, ottiene la radice quadrata di n che deve essere immessa nella barra degli indirizzi (es. Ppcg.php.net?n=213, dove 213 è il valore di n)
echo sqrt($_GET["n"]);
p=^4 :
bc<<<"sqrt($1)$p"Su Mac, shè in bashesecuzione in modalità Posix, e in questo caso come da https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html :
Le istruzioni di assegnazione che precedono i builtin speciali POSIX persistono nell'ambiente shell dopo il completamento del buildin
Pertanto per sh, la variabile pha il valore ^4dopo l' :esecuzione, ma per bash, la variabile pha questo valore solo quando :viene eseguita ed è vuota in seguito.
Essendo ancora davvero bashsotto le coperte, alcuni bashismi come i <<<maltrattamenti funzionano ancora sia per i casi bash che sh.
Su Ubuntu 16.01, shè presente un collegamento simbolico a dash, che non esegue i suoi <<<trasferimenti. Quindi abbiamo questo invece:
p=^4 :
echo "sqrt($1)$p"|bcQuesto programma piazza l'input in Cardinal e ottiene la radice quadrata in Octave
%:=t.
disp(sqrt(input("")))
Quindi% è un commento a riga singola in Octave, quindi ottiene solo input e stampa la radice quadrata
disp(sqrt(input("")))
In modo che il programma Cardinale non incontri una divisione per 0 errore e muoia, il programma
%:=t.
è stato spostato con uno spazio, che viene ignorato da entrambi i programmi
Il programma inizia con%
Riceve input e memorizza il valore come attivo:
imposta l'inattivo per essere uguale a attivo =
Moltiplica l'attivo per l'inattivo t
Infine emette il valore attivo.
<body onload=alert(<?=$x*$x.')>'.sqrt($x)?>
L'input è simile a:
<?php $x = 10; ?>
Un po 'autoesplicativo, ma si adatta alle regole? Il mio primo codice golf tho :-)
alert(<?=$x*$x.')>'.sqrt($x)?)
Non competitiva perché:
＋e ⓟ, CGL è tecnicamente un linguaggio valido. x=>x**2
//-₂
Semplice: una funzione freccia anonima che restituisce il suo primo argomento al quadrato. Il codice della lingua senza nome è commentato.
Lo spazio non-break prima della prima riga si comporta come un commento. Le /s sono vietate. Il -nei secondi mezzi di linea per diminuire il numero di stack corrente, che di default è 0. Ciò quindi imposta a -1, in cui è memorizzato ingresso. Il ₂sostituisce il primo elemento nella pila corrente con la sua radice quadrata, che è ora in cui è collocato ingresso. Per impostazione predefinita, viene emesso lo stack corrente, producendo la radice quadrata dell'input.