Você deve criar um poliglota que produza o quadrado da entrada em um idioma e a raiz quadrada da entrada em outro. A resposta mais curta em bytes vence!

Você deve ter uma precisão de pelo menos três casas decimais, e a entrada sempre será uma flutuação positiva.

Jolf e MATL , 1 byte

U

Raiz quadrada em Jolf, quadrada em MATL.

Experimente online! (MATL)

Experimente o código Jolf. Só funciona no Firefox.

Esses são 1 byte, pois MATL e Jolf usam páginas de código ASCII / ASCII estendidas, portanto, todos os comandos têm 1 byte.

C e C ++, 68 65 bytes

#include<math.h>
float f(float n){auto p=.5;return pow(n,2-p*3);}

Resposta original:

#include<math.h>
float f(float n){return pow(n,sizeof('-')-1?2:.5);}

Para ambas as versões, C produz n^2e C ++ produz sqrt(n).

Python 2 e Python 3, 23 21 bytes

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

O Python 2.x produz n^2, o Python 3.x produz sqrt(n).

_{2 bytes salvos graças ao @Dennis!}

2sable / Jelly , 2 bytes

*.

2sable calcula o quadrado. Experimente online!

Jelly calcula a raiz quadrada. Experimente online!

Como funciona

2sable

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

Geléia

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

C (clang) e Python , 109 107 69 53 bytes

#/*
lambda n:n**.5;'''*/
float a(i){return i*i;}//'''

C: Experimente online!

Python: Experimente online!

Funciona usando comentários para poliglota. O resto é bastante explicativo.

Primeira vez usando C!

• Economizei alguns bytes graças ao @Riker.
• Economizou 2 bytes removendo espaços em branco desnecessários.
• Salva muitos bytes usando uma função para C em vez de STDIN / OUT.
• Economizou 16 bytes graças a @Delioth removendo a instrução de importação na parte superior.

Ohm e geléia , 3 bytes

Emite o quadrado em Ohm, a raiz quadrada em Jelly.

Ohm e Jelly usam diferentes páginas de código de byte único, portanto, o programa aparecerá diferentemente em cada codificação.

xxd hexdump do programa:

00000000: fd7f 0a                                  ...

Geléia

Usando a página de código de Jelly, aparece assim:

’
½

A geléia considera que o link principal é o link principal e ignora os outros links, a menos que seja chamado especificamente. Então aqui ele apenas executa a raiz quadrada ( ½) e a gera implicitamente.

Ohm

Usando a página de código de Ohm (CP437), aparece assim:

²⌂◙

²é a função quadrado ⌂e ◙são indefinidos; portanto, o programa apenas encaixa a entrada de leitura implícita e a gera implicitamente.

C89 e C99, 47 + 3 = 50 bytes

float f(float n){return n//*
/sqrt(n)//*/1*n
;}

Requer -lmbandeira (+3)

C89 produz n^2, C99 produz sqrt(n). Para testar no C89, experimente online!

Conseguir que o C89 faça a sqrtversão deve levar menos código, mas ele insiste em declarar implicitamente a sqrtfunção com ints, portanto esse é o melhor que eu poderia gerenciar.

Oitava / MATLAB, 31 29 bytes

 @(x)x^(2-3*any(version>60)/2)

Isso gera o quadrado na oitava e a raiz quadrada no MATLAB.

Explicação:

A sintaxe é obviamente idêntica no MATLAB e no Octave (pelo menos para este pequeno pedaço de código).

Isso cria uma função 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)

Raiz quadrada em básico e quadrada em Delphi.

Você pode usar um depurador para inspecionar a expressão, cumprindo todos os requisitos de saída!

05AB1E / Bola de fogo , 3 bytes

Os seguintes bytes compõem o programa:

FD B9 74

05AB1E calcula raiz quadrada, quadrados Fireball.

Explicação (05AB1E - ý¹t):

ý       Pushes an empty string to the stack (not entirely sure why)
 ¹      Push first input
  t     Square root

Explicação (bola de fogo - ²╣t):

²       Square input
 ╣      Unassigned
  t     Unassigned

Às vezes, ajuda ter um idioma incompleto;)

PHP7 + JavaScript, 62 61 58 bytes

Isso foi realmente mais desafiador do que eu esperava! Estou bastante surpreso com a duração do meu código.

eval(['alert((_=prompt())*_)','echo$argv[1]**.5'][+![]]);

Como funciona?

Isso funciona selecionando o código a ser executado, a partir da matriz.
A detecção de PHP e JavaScript é feita com +![].

No PHP, [](matriz vazia) é um valor falso, enquanto no JavaScript é um valor verdadeiro (objetos (exceto null) são sempre verdadeiros, até mesmo new Boolean(false)é verdade!).
Mas, eu preciso obtê-lo com um valor numérico; portanto, basta usar a not( !) e convertê-lo em inteiro (com o +).
Agora, o PHP gera o valor 1, enquanto o JavaScript produz 0.
A colocação do código dentro de uma matriz, nesses índices, permitirá selecionar o código correto para o idioma desejado.
Isso pode ser usado como [JS,PHP][+![]], para obter o código do idioma correto.

Em poliglotas anteriores, eu usei '\0'=="\0", que é trueem JavaScript (desde \0é analisado como a NULL-byte) e falseem PHP (a '\0'não ser analisado como a NULL-byte, comparando a string literal \0com o NULL-byte).
Estou feliz por ter conseguido reduzir essa verificação para +!'0'.
Estou ainda mais feliz com o @rckd , que o reduziu à versão atual!

A partir daí, é simplesmente evalo código necessário.

PHP

O PHP executará echo$argv[1]**.5(equivalente a echo sqrt($argv[1]);raiz quadrada do número), recebendo o valor do segundo argumento e exibindo-o na saída padrão.

Javascript

O JavaScript é executado alert((_=prompt())*_), o que exibe o número ao quadrado em um alert.

Obrigado a @rckd por salvar 1 byte e a @ user59178 por salvar 3 bytes!

05AB1E e geléia , 4 bytes

nqƓ½

(05AB1E) - (Geléia)

nq   # Ignored by Jelly, push n**2 in 05AB1E then quit.
  Ɠ½ # Ignored by 05AB1E due to quit, push sqroot of input in Jelly.

Alguém fez uma boa observação, acho que os caracteres UTF-8 não compartilham a mesma operação nas páginas de código que tecnicamente possuem 2 bytes cada para codificar. No entanto, ao analisar isso em termos de despejo hexadecimal:

6e 71 93 0a

Na codificação CP1252 do 05AB1E, isso resulta em:

nq“\n

Ou seja, ele ainda emitirá o quadrado e sairá, ignorando o resto. Quando esses bytes são codificados usando a página de códigos de Jelly:

nqƓ½

Qual é o código original pretendido, quando executado, resulta no resultado desejado de pegar a entrada e pegar o sqrt.

CJam / MATL , 8 bytes

ld_*GX^!

Calcula o quadrado no CJam ( Experimente online! ) E a raiz quadrada no MATL ( Experimente online! ).

Explicação da praça no 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

Explicação da raiz quadrada em 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 e adiante, 43 33 bytes

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

Experimente online: Python 2 (quadrado) | Quarto (sqrt)

Isso avalia uma função anônima no Python e uma função fsqrtinterna no Forth. O Python pode ter uma função nomeada fpara mais 2 bytes, colocando f=na frente do lambda.

O programa Forth assume um literal de ponto flutuante , que Forth deve ser escrito em notação científica. Pi truncado com 3 casas decimais ( 3.141) seria escrito assim:

3141e-3

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

f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)

Retorna o quadrado da entrada no ES7 e a raiz quadrada no ES6. Muito difícil de testar, a menos que você tenha um navegador mais antigo que suporte o ES6, mas não o ES7.

f=a=>eval(`try{eval("a**2")}catch(e){Math.sqrt(a)}`)

console.log(f(4));

PHP e CJam , 30 29 25 bytes

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

Calcula o quadrado no PHP e a raiz quadrada no CJam. Tem que ser executado usando -rem PHP.

PHP

Eleva o primeiro argumento da linha de comando ( $argv[1]) à potência 2 e o gera. Aqui, $argv[1]na verdade, é colocado como uma variável embutida em uma string, que é convertida em um número antes de fazer a exponenciação. Isso ocorre porque vnão é uma instrução válida no CJam e causará erros durante a análise, mas colocá-lo em uma string não causará problemas.

# inicia um comentário, então tudo depois é ignorado.

Experimente online!

CJam

A primeira parte do código ECHO"$argv[1]"**2;#fornece um monte de valores e executa várias operações, todas inúteis. A única coisa importante é que eles não causam erros, porque logo em seguida é ];, o que envolve a pilha inteira em uma matriz e a descarta.

Depois disso, ele lê um duplo de input ( rd), obtém sua raiz quadrada ( mq) e a gera implicitamente.

Experimente online!

C, linguagem de script da Operação Flashpoint , 52 bytes

;float f(float x){return sqrt(x);}char*
F="_this^2";

Em um script OFP, um ponto e vírgula no início de uma linha faz dessa linha um comentário, enquanto C não se importa com o ponto e vírgula adicional.

C:

Experimente online!

Linguagem de script OFP:

Salve como init.sqsna pasta da missão e chame-a com hint format["%1", 2 call F].

Resultado:

Reticular / Befunge-98 , 15 bytes

Linguagens 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 o sinalizador '-v' em> <>)

Cara, estou realmente me divertindo com a estrutura de links Jelly.

:*n;
½

Calcula o quadrado em> <> e a raiz quadrada em 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)

Raiz quadrada em JS, quadrada em Python.

Funciona no Firefox (testado no FF 52) e requer (function(x) x)(42) === 42uma sintaxe válida. Também requer ES7 para o **operador.

bash e sh, 48 bytes

Atualização: Eu devo admitir a derrota. A resposta bash / sh do Digital Trauma é muito mais elegante que esta.

bc -l<<<"sqrt($1^(($(kill -l|wc -l)*3-3)/7+1))"

bash produz n^2, sh produz sqrt(n).

bcé necessário apenas para que sqrtpossa ser calculado. A diferença de comportamento é entre bash e sh.

OK, tecnicamente o "sh" que estou usando ainda é bash, mas bash no modo "POSIX" (o que acontece se você chamar em /bin/shvez de /bin/bashsistemas onde /bin/shexiste um alias para bash). Se este for o caso no seu sistema, você pode testar com:

/bin/bash prog.sh 4
/bin/sh prog.sh 4

Isso se baseia em uma das diferenças explicadas aqui: https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html

QBIC / QBasic, 26 18 bytes

input a
?a^2'^.25

No QBasic , ele pega um número e imprime esse número ao quadrado. O restante do código é ignorado porque o QBasic o vê como um comentário ( ').

QBIC usa a mesma instrução de entrada. Em seguida, imprimiu o mesmo número ao quadrado, depois aumentou para a potência de um quarto, efetivamente fazendo o root duas vezes. Isso ocorre porque 'é visto como um literal de código: código QBasic puro que não é analisado pelo QBIC.

Gelatina / Pip , 6 bytes

EDIT: É um byte mais curto para reverter as operações.

RTa
²

Experimente o Jelly online!

O Jelly inicia a execução na parte inferior do código (seu 'link principal') e vê se precisa de algo mais alto: vê o comando quadrado e cuida da entrada e da saída implicitamente.

Experimente o Pip online!

O Pip executa a linha superior, esquadrando a var (leitura implicitamente da linha cmd) var a e imprimindo isso implicitamente. A linha inferior é ignorada.

Wolfram Language / PHP , 25 bytes

Obtenha o quadrado de um número na Wolfram Language e a raiz quadrada em PHP;

n^2
echo sqrt(_GET["n"]);

A primeira linha é a Wolfram Language. Primeiro, é você quem altera n na barra de pesquisa no Wolfram Alpha, para que o código também seja a entrada. Então ele irá gerar a resposta ao pressionar enter

n^2

A segunda linha é PHP, obtém a raiz quadrada de n que deve ser inserida na barra de endereço (por exemplo, ppcg.php.net?n=213, onde 213 é o valor de n)

echo sqrt($_GET["n"]);

PHP 5.6 e PHP 7, 55 bytes

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

O PHP 5.6 produz n^2, o PHP 7 produz sqrt(n).

macOS Bash e sh, 24 bytes

p=^4 :
bc<<<"sqrt($1)$p"

No Mac, shestá bashsendo executado no modo Posix e, neste caso, conforme https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html :

As instruções de atribuição que precedem os buildins especiais POSIX persistem no ambiente de shell após a conclusão do buildin

Assim sh, para , a variável ptem o valor ^4após a :execução, mas para bash, a variável psó possui esse valor enquanto :é executada e fica vazia depois.

Ainda estando realmente bashocultos, alguns basismos como os <<<herestrings ainda funcionam nos casos bash e sh.

Bash and dash (e utilitários GNU), 27

No Ubuntu 16.01, shé um link simbólico para dash, que não faz <<<herestrings. Então, temos isso:

p=^4 :
echo "sqrt($1)$p"|bc

Experimente online .

Oitava / Cardinal , 28 bytes

Este programa esquadrinha a entrada no Cardinal e obtém a raiz quadrada na oitava

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

Experimente online! (Oitava)

Experimente online! (Cardeal)

Portanto,% é um comentário de linha única no Octave, para que apenas obtenha entrada e imprima a raiz quadrada

disp(sqrt(input("")))

Para que o programa Cardinal não encontre um erro de divisão por 0 e morra, o programa

%:=t.

foi deslocado com um espaço, que é ignorado pelos dois programas

Explicação do programa Cardinal:

O programa inicia na%
. Recebe entrada e armazena o valor como ativo:
Define o inativo igual ao ativo =
Multiplica o ativo pelo inativo t
Finalmente, ele gera o valor ativo.

PHP / JavaScript, 43 bytes

<body onload=alert(<?=$x*$x.')>'.sqrt($x)?>

A entrada é como:

<?php $x = 10; ?>

Meio auto-explicativo, mas isso se encaixa nas regras? Meu primeiro código de golfe tho :-)

CGL (CGL Golfing Language) / JS (ES6), 13 bytes (não concorrente)

Não concorrente porque:

1. O CGL foi lançado após esta pergunta.
2. CGL não é um idioma válido . Por causa de ＋e ⓟ, CGL é tecnicamente uma linguagem válida.

Código:

 x=>x**2
//-₂

JS:

Simples: uma função de seta anônima que retorna seu primeiro argumento ao quadrado. O código do idioma sem nome está comentado.

CGL:

O espaço sem quebra antes da primeira linha atua como um comentário. Os /s não são ops. A -segunda linha significa diminuir o número atual da pilha, que por padrão é 0. Isso então o define como -1, onde a entrada é armazenada. Ele ₂substitui o primeiro item da pilha atual por sua raiz quadrada, que agora é onde a entrada é colocada. Por padrão, a pilha atual é gerada, gerando a raiz quadrada da entrada.