Debe hacer un políglota que genere el cuadrado de la entrada en un idioma y la raíz cuadrada de la entrada en otro. ¡La respuesta más corta en bytes gana!
Debe tener una precisión de al menos 3 decimales, y la entrada siempre será un flotante positivo.
Respuestas:
U
Raíz cuadrada en Jolf, cuadrada en MATL.
Pruébalo en línea! (MATL)
Prueba el código Jolf. Solo funciona en Firefox.
Ambos son de 1 byte, ya que MATL y Jolf usan páginas de códigos ASCII / ASCII extendido, por lo que todos los comandos son de 1 byte.
#include<math.h>
float f(float n){auto p=.5;return pow(n,2-p*3);}
Respuesta original:
#include<math.h>
float f(float n){return pow(n,sizeof('-')-1?2:.5);}
Para ambas versiones, C produce n^2y C ++ produce sqrt(n).
autosignifica "asignar en la pila". La palabra clave es bastante inútil porque ese es el valor predeterminado de todos modos, por lo que C ++ la reutilizó para que signifique algo más. En C, sin embargo, no expresa ninguna opinión sobre el tipo de p(es una clase de almacenamiento, no un tipo), por lo que cuenta como un intvalor predeterminado (este intcomportamiento predeterminado se desaconseja hoy en día, y probablemente solo existe porque algunos de los predecesores de C no tenían ningún tipo de datos, pero los compiladores aún lo entienden). Y, por supuesto, (int)0.5es 0.
n^2.
lambda n:n**(1/2or 2)Python 2.x produce n^2, Python 3.x produce sqrt(n).
¡2 bytes guardados gracias a @Dennis!
or?
/hace división entera ( 1/2==0). En Py3, hace división de coma flotante ( 1/2==0.5). 0Es falsey.
*.
2sable calcula el cuadrado. Pruébalo en línea!
Jelly calcula la raíz cuadrada. Pruébalo en línea!
* 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;}//'''C: ¡ Pruébelo en línea!
Python: ¡ Pruébalo en línea!
Funciona mediante el uso de comentarios para políglota. El resto es bastante explicativo.
Primera vez usando C!
return 0;desde el final: C99 contiene un retorno implícito de 0 main()específicamente. Fuente
stdio.hen ese caso?
Emite el cuadrado en ohmios, la raíz cuadrada en gelatina.
Ohm y Jelly usan diferentes páginas de códigos de un solo byte, por lo que el programa aparecerá de manera diferente en cada codificación.
xxd hexdump del programa:
00000000: fd7f 0a ...
Usando la página de códigos de Jelly, aparece así:
’
½
Jelly toma la línea inferior como su enlace principal, e ignora los otros enlaces a menos que se llame específicamente. Entonces, aquí solo hace la raíz cuadrada ( ½) y la genera implícitamente.
Usando la página de códigos de Ohm (CP437), aparece así:
²⌂◙
²es la función cuadrado, y ⌂y ◙son a la vez sin definir, por lo que el programa sólo las plazas de la entrada implícita leer e implícitamente la emite.
½byte, ¿a qué se dirige el ²mapa? ¿Es solo basura que todavía se ignora? ¿Y viceversa para Ohm? Entonces parecería ser de 2 bytes.
²en Ohm está en el punto de código 5. El punto de código 5 en Jelly es %y no hace nada, por lo que no importa cuál sea la primera línea. Supongamos que ½en Jelly está en 27, y el punto de código 27 en Ohm es Jy no hace nada, por lo que no importa cuál sea la segunda línea. Por lo tanto, si tiene un archivo de 00000101<newline>000110113 bytes. Supongo que el único problema es si la nueva línea está en una ubicación diferente en las páginas de códigos.
float f(float n){return n//*
/sqrt(n)//*/1*n
;}Requiere -lmbandera (+3)
C89 produce n^2, C99 produce sqrt(n). Para probar en C89, ¡pruébelo en línea!
Hacer que C89 haga la sqrtversión debería tomar menos código, pero insiste en declarar implícitamente la sqrtfunción con ints, por lo que esto es lo mejor que pude manejar.
@(x)x^(2-3*any(version>60)/2)
Esto genera el cuadrado en octava y la raíz cuadrada en MATLAB.
Explicación:
La sintaxis es, por supuesto, idéntica en MATLAB y Octave (al menos para este pequeño fragmento de código).
Esto crea una función anónima:
@(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)
Raíz cuadrada en Basic y cuadrada en Delphi.
¡Puede usar un depurador para inspeccionar la expresión, cumpliendo así los requisitos de salida!
x? No puede asumir que está guardado en un valor. Pero es posible que pueda eliminarlo (x)y etiquetarlo como retornando una función.
Los siguientes bytes forman el programa:
FD B9 74
05AB1E calcula raíz cuadrada, cuadrados de bola de fuego.
Explicación (05AB1E - ý¹t):
ý Pushes an empty string to the stack (not entirely sure why)
¹ Push first input
t Square root
Explicación (Bola de fuego - ²╣t):
² Square input
╣ Unassigned
t Unassigned
A veces, ayuda tener un lenguaje incompleto;)
¡Esto fue en realidad más desafiante de lo que esperaba! Estoy bastante sorprendido de cuánto dura mi código.
eval(['alert((_=prompt())*_)','echo$argv[1]**.5'][+![]]);¿Como funciona?
Esto funciona seleccionando el código a ejecutar, desde la matriz.
La detección de PHP y JavaScript se realiza con +![].
En PHP, [](matriz vacía) es un valor falso, mientras que en JavaScript es un valor verdadero (los objetos (excepto null) siempre son verdaderos, ¡incluso new Boolean(false)son verdaderos!).
Pero, necesito obtener un valor numérico, así que solo uso a not( !) y lo convierto a entero (con el +).
Ahora, PHP produce el valor 1, mientras que JavaScript produce 0.
Colocar el código dentro de una matriz, en esos índices, nos permitirá seleccionar el código correcto para el idioma deseado.
Esto se puede usar como [JS,PHP][+![]], para obtener el código del idioma correcto.
En políglotas anteriores, he usado '\0'=="\0", que está trueen JavaScript (ya que \0se analiza como el byte NULL) y falseen PHP ( '\0'no se analizará como el byte NULL, comparando la cadena literal \0con el byte NULL).
Estoy feliz de haber logrado reducir este cheque a +!'0'.
¡Estoy aún más feliz con @rckd , que lo redujo a la versión actual!
A partir de ahí, simplemente evales el código requerido.
PHP
PHP se ejecutará echo$argv[1]**.5(equivalente a echo sqrt($argv[1]);la raíz cuadrada del número), recibirá el valor del segundo argumento y lo mostrará en la salida estándar.
JavaScript
Se ejecuta JavaScript alert((_=prompt())*_), que muestra el número al cuadrado en un alert.
¡Gracias a @rckd por guardar 1 byte y a @ user59178 por guardar 3 bytes!
echo$argv[1]**.5lugar deecho 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.
Alguien más hizo un buen punto, supongo que dado que los caracteres UTF-8 no comparten la misma operación en las páginas de códigos que técnicamente tienen 2 bytes cada uno para codificar. Sin embargo, al mirar esto en términos del volcado hexadecimal:
6e 71 93 0a
En la codificación CP1252 de 05AB1E esto da como resultado:
nq“\n
Lo que significa que aún generará el cuadrado y se cerrará, ignorando el resto. Cuando estos bytes se codifican con la página de códigos de Jelly:
nqƓ½
Cuál es el código original deseado, cuando se ejecuta, da como resultado el resultado deseado de tomar la entrada y tomar el sqrt.
Ɠy ½requieren dos bytes para ser codificados. Sin embargo, la secuencia de bytes 6e 71 93 0a( nqƓ½para Jelly, nq“\npara CP-1252) debería funcionar en ambos idiomas.
½estar en ambas páginas de códigos no permite que cuente como una sola porque supongo que son operaciones diferentes. Todavía estoy borroso en toda la página de códigos.
6e 71 93 0apor lo que no hay "teóricamente" sobre reclamar 4 bytes. Solo reclama 4 bytes. Sucede que en la codificación estándar de 05AB1E, lee una cosa que hace lo que quiere, mientras que en la codificación estándar de Jelly, lee otra que hace lo que quiere. Además, el hecho de que 2 codificaciones puedan codificar el mismo personaje no significa que ese personaje sea el mismo en ambos. Solo piense en las codificaciones como un cifrado numérico con una tabla de búsqueda ya compartida y con suerte eso le dará un buen modelo mental inicial.
ld_*GX^!
Calcula el cuadrado en CJam (¡ Pruébelo en línea! ) Y la raíz cuadrada en MATL (¡ Pruébelo en línea! ).
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*nPruébelo en línea: Python 2 (cuadrado) | Adelante (sqrt)
Esto se evalúa como una función anónima en Python y una función incorporada fsqrten Forth. Python puede tener una función con nombre fpara 2 bytes más al poner f=delante de la lambda.
El programa Forth toma un literal de coma flotante , que en Forth debe escribirse en notación científica. Pi truncado a 3 decimales ( 3.141) se escribiría así:
3141e-3
f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)
Devuelve el cuadrado de la entrada en ES7 y la raíz cuadrada en ES6. Bastante difícil de probar, a menos que tenga un navegador más antiguo que admita ES6 pero no ES7.
f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)
console.log(f(4));ECHO"$argv[1]"**2;#];rdmq
Calcula el cuadrado en PHP y la raíz cuadrada en CJam. Tiene que ejecutarse usando -ren PHP.
Eleva el primer argumento de línea de comando ( $argv[1]) a la potencia 2 y lo emite. Aquí en $argv[1]realidad se coloca como una variable en línea en una cadena, que se convierte en un número antes de hacer la exponenciación. Esto se debe a vque no es una instrucción válida en CJam y hará que se produzca un error al analizar, pero ponerlo en una cadena no causará ningún problema.
# comienza un comentario, por lo que todo lo que sigue se ignora.
La primera parte del código, ECHO"$argv[1]"**2;#empuja un montón de valores y realiza un montón de operaciones, todas las cuales son completamente inútiles. Lo único importante es que no causan ningún error, porque inmediatamente después ];, envuelve toda la pila en una matriz y luego la descarta.
Después de eso, lee un doble de input ( rd), y obtiene su raíz cuadrada ( mq), y lo emite implícitamente.
;float f(float x){return sqrt(x);}char*
F="_this^2";
En un script OFP, un punto y coma al principio de una línea hace que esa línea sea un comentario, mientras que a C no le importa el punto y coma adicional.
C:
Lenguaje de script OFP:
Guarde como init.sqsen la carpeta de la misión, luego llámelo con hint format["%1", 2 call F].
Resultado: 
Lenguajes 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
Hombre, realmente me estoy divirtiendo con la estructura de enlaces Jelly.
:*n;
½
-vestá, en mi opinión, en línea con la [respuesta más votada [( codegolf.meta.stackexchange.com/a/11431/44874 ) en una meta pregunta que maneja este caso. El ><>intérprete lo necesita -vy por eso es la invocación más simple posible.
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)Raíz cuadrada en JS, cuadrada en Python.
Funciona en Firefox (probado en FF 52) y requiere (function(x) x)(42) === 42ser una sintaxis válida. También requiere ES7 para el **operador.
x=>x**yen su lugar? ¿O Python se ahogará con eso?
functionno es una palabra clave, es un identificador válido. Entonces solo le asigné una función noop (dentro de la execdeclaración).
Actualización: debo reconocer la derrota. La respuesta bash / sh de Digital Trauma es mucho más elegante que esta.
bc -l<<<"sqrt($1^(($(kill -l|wc -l)*3-3)/7+1))"bash produce n^2, sh produce sqrt(n).
bcsolo es necesario para que sqrtpueda calcularse. La diferencia en el comportamiento es entre bash y sh.
OK, técnicamente el "sh" que estoy usando sigue siendo bash, pero bash en modo "POSIX" (que ocurre si invoca en /bin/shlugar de /bin/bashen sistemas donde /bin/shhay un alias para bash). Si este es el caso en su sistema, puede probar con:
/bin/bash prog.sh 4
/bin/sh prog.sh 4Esto se basa en una de las diferencias explicadas aquí: https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
kill -l(enumera las posibles señales; no cambia nada) en bashy sh. Es una de las muchas diferencias que puede encontrar aquí: gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
input a
?a^2'^.25
En QBasic , toma un número e imprime ese número al cuadrado. El resto del código se ignora porque QBasic lo ve como un comentario ( ').
QBIC usa la misma declaración de entrada. Luego pasó a imprimir el mismo número al cuadrado, luego se elevó a la potencia de un cuarto, enraizándolo efectivamente dos veces. Esto se debe a que 'se ve como un código literal: código QBasic puro que QBIC no analiza.
EDITAR: es un byte más corto para invertir operaciones.
RTa
²
Jelly comienza la ejecución en la parte inferior del código (su 'enlace principal') y ve si necesita algo más alto: ve el comando al cuadrado y se encarga de la entrada y salida implícitamente.
Pip ejecuta la línea superior, cuadrando la var a (implícitamente leída de la línea cmd) e imprime eso implícitamente. El resultado final se ignora.
PRTaVS.
Obtenga el cuadrado de un número en Wolfram Language y obtenga la raíz cuadrada en PHP;
n^2
echo sqrt(_GET["n"]);
La primera línea es Wolfram Language. Primero, ustedes son los que cambian n en la barra de búsqueda en Wolfram Alpha, por lo que el código también es la entrada. Luego generará la respuesta al presionar enter
n^2
La segunda línea es PHP. Obtiene la raíz cuadrada de la n que se ingresará en la barra de direcciones (por ejemplo, ppcg.php.net?n=213, donde 213 es el valor de n)
echo sqrt($_GET["n"]);
p=^4 :
bc<<<"sqrt($1)$p"En Mac, shse bashejecuta en modo Posix, y en este caso según https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html :
Las declaraciones de asignación que preceden a las construcciones especiales POSIX persisten en el entorno de shell después de que la construcción completa
Por lo tanto sh, para , la variable ptiene el valor ^4después de :ejecutarse, pero para bash, la variable psolo tiene este valor mientras :se ejecuta, y luego está vacía.
Al estar todavía realmente bashbajo las sábanas, algunos bashismos como las <<<herejías todavía funcionan tanto para los casos bash como para los sh.
En Ubuntu 16.01, shes un enlace simbólico a dash, que no hace <<<herejías. Entonces tenemos esto en su lugar:
p=^4 :
echo "sqrt($1)$p"|bcEste programa ajusta la entrada en Cardinal y obtiene la raíz cuadrada en Octave
%:=t.
disp(sqrt(input("")))
Por lo tanto,% es un comentario de una sola línea en Octave, por lo que solo recibe información e imprime la raíz cuadrada
disp(sqrt(input("")))
Para que el programa Cardinal no encuentre una división por 0 error y muera, el programa
%:=t.
se ha cambiado con un espacio, que es ignorado por ambos programas
El programa comienza en el%.
Recibe la entrada y almacena el valor como activo:
establece que el inactivo sea igual al activo =
multiplica el activo por el inactivo.
Finalmente, emite el valor activo.
<body onload=alert(<?=$x*$x.')>'.sqrt($x)?>
La entrada es como:
<?php $x = 10; ?>
Un poco autoexplicativo, pero ¿se ajusta a las reglas? Mi primer código de golf aunque :-)
alert(<?=$x*$x.')>'.sqrt($x)?)
No compite porque:
＋y ⓟ, CGL es técnicamente un lenguaje válido. x=>x**2
//-₂
Simple: una función de flecha anónima que devuelve su primer argumento al cuadrado. El código de idioma sin nombre se comenta.
El espacio sin interrupción antes de la primera línea actúa como un comentario. Los /s son no-ops. El -en la segunda línea significa disminuir el número de pila actual, que por defecto es 0. Eso lo establece en -1, donde se almacena la entrada. El ₂reemplaza el primer elemento en la pila actual con su raíz cuadrada, que ahora es donde se coloca la entrada. Por defecto, se genera la pila actual, generando la raíz cuadrada de la entrada.