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.

Jolf y MAT , 1 byte

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.

C y C ++, 68 65 bytes

#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).

Python 2 y Python 3, 23 21 bytes

lambda n:n**(1/2or 2)

Python 2.x produce n^2, Python 3.x produce sqrt(n).

_{¡2 bytes guardados gracias a @Dennis!}

2sable / Jelly , 2 bytes

*.

2sable calcula el cuadrado. Pruébalo en línea!

Jelly calcula la raíz cuadrada. Pruébalo en línea!

Cómo funciona

2sable

*   Read the input twice and compute the product of both copies.
    This pushes the square of the input.
 .  Unrecognized token (ignored).

Jalea

 .  Numeric literal; yield 0.5.
*   Raise the input to the power 0.5.
    This yields the square root.

C (sonido metálico) y Python , 109 107 69 53 bytes

#/*
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!

• Ahorré bastantes bytes gracias a @Riker.
• Ahorró 2 bytes eliminando espacios en blanco innecesarios.
• Se guardaron muchos bytes usando una función para C en lugar de STDIN / OUT.
• Ahorró 16 bytes gracias a @Delioth al eliminar la declaración de importación en la parte superior.

Ohm and Jelly , 3 bytes

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                                  ...

Jalea

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.

Ohm

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.

C89 y C99, 47 + 3 = 50 bytes

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.

Octava / MATLAB, 31 29 bytes

 @(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')

Básico / Delphi - 6 caracteres

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!

05AB1E / Fireball , 3 bytes

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

PHP7 + JavaScript, 62 61 58 bytes

¡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!

05AB1E y Jelly , 4 bytes

nqƓ½

(05AB1E) - (Gelatina )

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.

CJAM / MAT , 8 bytes

ld_*GX^!

Calcula el cuadrado en CJam (¡ Pruébelo en línea! ) Y la raíz cuadrada en MATL (¡ Pruébelo en línea! ).

Explicación del cuadrado en CJam

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

Explicación de la raíz cuadrada en MATL

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

Python 2 y adelante, 43 33 bytes

( """ )
fsqrt
\ """);lambda n:n*n

Prué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

JavaScript (ES6) / JavaScript (ES7), 52 bytes

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

PHP y CJam , 30 29 25 bytes

ECHO"$argv[1]"**2;#];rdmq

Calcula el cuadrado en PHP y la raíz cuadrada en CJam. Tiene que ejecutarse usando -ren PHP.

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.

Pruébalo en línea!

CJam

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.

Pruébalo en línea!

C, lenguaje de scripting Operation Flashpoint , 52 bytes

;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:

Pruébalo en línea!

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:

Reticular / Befunge-98 , 15 bytes

Lenguajes 2D!

/&:*.@
>in:o#p;

Befunge-98

/&:*.@

/          divide top two (no-op)
 &         read decimal input
  :        duplicate
   *       square
    .      output
     @     terminate

Reticular

/           mirror up, then right
>in:o#p;

 i          read line of input
  n         cast to number
   :o#      square root
      p     print
       ;    terminate

> <> / Jelly , 9 bytes (código de 7 bytes + 2 para el indicador '-v' en> <>)

Hombre, realmente me estoy divirtiendo con la estructura de enlaces Jelly.

:*n;
½

Calcula el cuadrado en> <> y la raíz cuadrada en Jelly .

Python 3 + JavaScript, 101 bytes

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.

bash y sh, 48 bytes

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 4

Esto se basa en una de las diferencias explicadas aquí: https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html

QBIC / QBasic, 26 18 bytes

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.

Jalea / Pip , 6 bytes

EDITAR: es un byte más corto para invertir operaciones.

RTa
²

¡Prueba Jelly en línea!

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.

¡Prueba Pip en línea!

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.

Wolfram Language / PHP , 25 bytes

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"]);

PHP 5.6 y PHP 7, 55 bytes

function f($n){list($a[],$a[])=[.5,2];echo $n**$a[0];}

PHP 5.6 produce n^2, PHP 7 produce sqrt(n).

macOS Bash y sh, 24 bytes

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.

Bash and dash (y GNU utils), 27

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"|bc

Pruébalo en línea .

Octava / Cardenal , 28 bytes

Este programa ajusta la entrada en Cardinal y obtiene la raíz cuadrada en Octave

 %:=t.
disp(sqrt(input("")))

Pruébalo en línea! (Octava)

Pruébalo en línea! (Cardenal)

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

Explicación del programa Cardinal:

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.

PHP / JavaScript, 43 bytes

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

CGL (lenguaje de golf CGL) / JS (ES6), 13 bytes (no competidor)

No compite porque:

1. CGL fue lanzado después de esta pregunta.
2. CGL no es un lenguaje válido . Debido a ＋y ⓟ, CGL es técnicamente un lenguaje válido.

Código:

 x=>x**2
//-₂

JS:

Simple: una función de flecha anónima que devuelve su primer argumento al cuadrado. El código de idioma sin nombre se comenta.

CGL:

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.