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.
Respostas:
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.
#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).
autosignifica "alocar na pilha". A palavra-chave é bastante inútil porque, de qualquer maneira, é o padrão; portanto, o C ++ a reformulou para significar outra coisa. Em C, no entanto, ele não expressa nenhuma opinião sobre o tipo de p(é uma classe de armazenamento, não um tipo), por isso conta como intpadrão (esse padrão de intcomportamento é desencorajado atualmente e provavelmente só existe porque alguns dos antecessores de C não tinham nenhum tipo de dado, mas os compiladores ainda o entendem). E, claro, (int)0.5é 0.
n^2.
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!
or?
/faz divisão inteira ( 1/2==0). Em PY3, ele divisão de ponto flutuante ( 1/2==0.5). 0É Falsey.
*.
2sable calcula o quadrado. Experimente online!
Jelly calcula a raiz quadrada. Experimente 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: Experimente online!
Funciona usando comentários para poliglota. O resto é bastante explicativo.
Primeira vez usando C!
return 0;do final - C99 mantém um retorno implícito de 0 main()especificamente. Fonte
stdio.hnesse caso?
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 ...
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.
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.
½byte, para que serve o ²mapa? É apenas lixo que ainda é ignorado? E vice-versa para Ohm? Então parece ter 2 bytes.
²em Ohm esteja no ponto de código 5. O ponto de código 5 em Jelly é %e não faz nada, portanto, não importa qual seja a primeira linha. Suponha que ½Jelly esteja em 27 e o ponto de código 27 em Ohm seja Je não faça nada, portanto, não importa qual seja a segunda linha. Portanto, se você possui um arquivo 00000101<newline>00011011, são 3 bytes. Eu acho que o único problema é se a nova linha estiver em um local diferente nas páginas de código.
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.
@(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')
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!
x? Você não pode assumir que ele foi salvo em um valor. Mas você pode realmente remover o (x)e rotulá-lo como retornando uma função.
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;)
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!
echo$argv[1]**.5vez 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.
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.
Ɠe ½exigem a codificação de dois bytes. No entanto, a sequência de bytes 6e 71 93 0a( nqƓ½para Jelly, nq“\npara CP-1252) deve funcionar nos dois idiomas.
½estar nas duas páginas de código não permite que ele conte como um único, porque são operações diferentes, eu assumo? Ainda estou confuso com toda a coisa da página de código.
6e 71 93 0aportanto não há teoricamente a reivindicação de 4 bytes. Apenas reivindique 4 bytes. Acontece que na codificação padrão do 05AB1E, ele lê uma coisa que faz o que você deseja, enquanto na codificação padrão da Jelly, ele lê outra que faz o que você deseja. Como um aparte, apenas porque duas codificações podem codificar o mesmo caractere não significa que o caractere será o mesmo em ambos. Pense em codificações como um código numérico com uma tabela de pesquisa já compartilhada e espero que isso lhe dê um bom modelo mental inicial.
ld_*GX^!
Calcula o quadrado no CJam ( Experimente online! ) E a raiz quadrada no MATL ( Experimente 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*nExperimente 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
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));ECHO"$argv[1]"**2;#];rdmq
Calcula o quadrado no PHP e a raiz quadrada no CJam. Tem que ser executado usando -rem 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.
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.
;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:
Linguagem de script OFP:
Salve como init.sqsna pasta da missão e chame-a com hint format["%1", 2 call F].
Resultado: 
Linguagens 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
Cara, estou realmente me divertindo com a estrutura de links Jelly.
:*n;
½
-vestá, na minha opinião, alinhado com a [resposta mais votada [( codegolf.meta.stackexchange.com/a/11431/44874 )) em uma meta-pergunta que trata desse caso. O ><>intérprete precisa disso -ve é por isso a invocação mais simples possível.
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.
x=>x**ylugar? Ou Python vai engasgar com isso?
functionnão é uma palavra-chave, é um identificador válido. Então, acabei de atribuir uma função noop a ela (dentro da execinstrução).
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 4Isso se baseia em uma das diferenças explicadas aqui: https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
kill -l(lista os sinais possíveis; não muda nada) em bashe sh. É uma das muitas diferenças que você pode encontrar aqui: gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html
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.
EDIT: É um byte mais curto para reverter as operações.
RTa
²
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.
O Pip executa a linha superior, esquadrando a var (leitura implicitamente da linha cmd) var a e imprimindo isso implicitamente. A linha inferior é ignorada.
PRTaVS.
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"]);
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.
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"|bcEste programa esquadrinha a entrada no Cardinal e obtém a raiz quadrada na oitava
%:=t.
disp(sqrt(input("")))
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
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.
<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 :-)
alert(<?=$x*$x.')>'.sqrt($x)?) #
Não concorrente porque:
＋e ⓟ, CGL é tecnicamente uma linguagem válida. x=>x**2
//-₂
Simples: uma função de seta anônima que retorna seu primeiro argumento ao quadrado. O código do idioma sem nome está comentado.
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.