Vous devez créer un polyglotte qui affiche le carré de l'entrée dans une langue et la racine carrée de l'entrée dans une autre. La réponse la plus courte en octets gagne!

Vous devez avoir une précision d'au moins 3 décimales et l'entrée sera toujours un flottant positif.

Jolf et MATL , 1 octet

U

Racine carrée chez Jolf, carré chez MATL.

Essayez-le en ligne! (MATL)

Essayez le code Jolf. Ne fonctionne que sur Firefox.

Il s’agit de deux octets, MATL et Jolf utilisant tous les deux des pages de code ASCII / ASCII étendu, de sorte que toutes les commandes ont un octet.

C et C ++, 68 à 65 octets

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

Réponse originale:

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

Pour les deux versions, C produit n^2et C ++ produit sqrt(n).

Python 2 et Python 3, 23 21 octets

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

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

_{2 octets sauvés grâce à @Dennis!}

2sable / Jelly , 2 octets

*.

2sable calcule le carré. Essayez-le en ligne!

La gelée calcule la racine carrée. Essayez-le en ligne!

Comment ça fonctionne

2sable

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

Gelée

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

C (clang) et Python , 109 107 69 53 octets

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

C: Essayez-le en ligne!

Python: essayez-le en ligne!

Fonctionne en utilisant des commentaires à polyglot. Le reste est assez explicatif.

Première fois en utilisant C!

• Économisé quelques octets grâce à @Riker.
• 2 octets enregistrés en supprimant les espaces inutiles.
• Sauvegardé de très nombreux octets en utilisant une fonction pour C au lieu de STDIN / OUT.
• Sauvegardé 16 octets grâce à @Delioth en supprimant l'instruction d'importation en haut.

Ohm and Jelly , 3 octets

Affiche le carré en Ohm et la racine carrée dans Jelly.

Ohm et Jelly utilisent des pages de codes à un octet différentes, de sorte que le programme apparaît différemment dans chaque codage.

xxd hexdump du programme:

00000000: fd7f 0a                                  ...

Gelée

En utilisant la page de code de Jelly, cela ressemble à ceci:

’
½

Jelly considère que la ligne du bas est son lien principal et ignore les autres liens, sauf indication contraire. Donc, ici, il ne fait que la racine carrée ( ½) et le sort implicitement.

Ohm

En utilisant la page de codes d'Ohm (CP437), il se présente comme suit:

²⌂◙

²est la fonction carrée, et ⌂et ◙sont tous les deux indéfinis, de sorte que le programme met en carré l'entrée lue implicitement et la renvoie implicitement.

C89 et C99, 47 + 3 = 50 octets

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

Nécessite le -lmdrapeau (+3)

C89 produit n^2, C99 produit sqrt(n). Pour tester en C89, essayez-le en ligne!

Obtenir que C89 fasse la sqrtversion devrait prendre moins de code, mais il insiste pour déclarer implicitement la sqrtfonction avec ints, c'est donc le mieux que je puisse gérer.

Octave / MATLAB, 31 29 octets

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

Cela donne le carré dans Octave et la racine carrée dans MATLAB.

Explication:

La syntaxe est bien sûr identique dans MATLAB et Octave (pour ce petit morceau de code au moins).

Cela crée une fonction anonyme:

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

Basic / Delphi - 6 caractères

sqr(x)

Racine carrée en Basic et carrée en Delphi.

Vous pouvez utiliser un débogueur pour inspecter l'expression, remplissant ainsi toutes les exigences de sortie!

05AB1E / Fireball , 3 octets

Les octets suivants constituent le programme:

FD B9 74

05AB1E calcule la racine carrée, les carrés Fireball.

Explication (05AB1E - ý¹t):

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

Explication (Fireball - ²╣t):

²       Square input
 ╣      Unassigned
  t     Unassigned

Parfois, il est utile d’avoir une langue incomplète;)

PHP7 + JavaScript, 62 61 58 octets

C'était plus difficile que prévu! Je suis assez surpris de la longueur de mon code.

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

Comment ça marche?

Cela fonctionne en sélectionnant le code à exécuter, à partir du tableau.
La détection PHP et JavaScript est faite avec +![].

En PHP, [](un tableau vide) est une valeur falsy, alors que dans JavaScript, il s'agit d'une valeur de vérité (les objets (sauf null) sont toujours en vérité, et même en new Boolean(false)vérité!).
Mais, je dois obtenir une valeur numérique, alors, je viens d'utiliser un not( !) et de le convertir en entier (avec le +).
Maintenant, PHP donne la valeur 1, alors que JavaScript donne 0.
Placer le code dans un tableau, à ces index, nous permettra de sélectionner le bon code pour la langue désirée.
Ceci peut être utilisé comme [JS,PHP][+![]], pour obtenir le code de la bonne langue.

Sur les polyglottes précédentes, j'ai utilisé '\0'=="\0", qui est trueen JavaScript (depuis \0est analysé comme l'octet NULL) et falseen PHP (le '\0'ne sera pas analysé comme l'octet NULL, en comparant la chaîne littérale \0avec l'octet NULL).
Je suis heureux d'avoir réussi à réduire ce chèque à +!'0'.
Je suis encore plus content de @rckd , qui l'a réduit à la version actuelle!

A partir de là, c’est tout simplement evalle code requis.

PHP

PHP s'exécutera echo$argv[1]**.5(équivalent echo sqrt($argv[1]);du nombre correspondant à la racine carrée), recevra la valeur du deuxième argument et l'affichera dans la sortie standard.

JavaScript

JavaScript s'exécute alert((_=prompt())*_), ce qui affiche le nombre au carré dans un fichier alert.

Merci à @rckd pour la sauvegarde de 1 octet et à @ user59178 pour la sauvegarde de 3 octets!

05AB1E et Jelly , 4 octets

nqƓ½

(05AB1E) - (Gelée)

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

Je suppose que quelqu'un d'autre a fait valoir un bon point, car les caractères UTF-8 ne partagent pas la même opération sur des pages de code qu'ils sont techniquement sur deux octets à encoder. Cependant, en ce qui concerne le vidage hexadécimal:

6e 71 93 0a

Avec le codage CP1252 de 05AB1E, cela se traduit par:

nq“\n

Cela signifie que le carré restera affiché et quittera, ignorant le reste. Lorsque ces octets sont codés à l'aide de la page de code de Jelly:

nqƓ½

Quel est le code d'origine prévu, une fois exécuté, donne le résultat souhaité: prendre l'entrée et prendre le sqrt.

CJam / MATL , 8 octets

ld_*GX^!

Calcule le carré dans CJam ( Essayez-le en ligne! ) Et la racine carrée dans MATL ( Essayez-le en ligne! ).

Explication de la place dans 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

Explication de la racine carrée dans 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 et Forth, 43 33 octets

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

Essayez-le en ligne: Python 2 (carré) | Forth (sqrt)

Cela donne une fonction anonyme en Python et une fonction intégrée fsqrtdans Forth. Python peut avoir une fonction nommée fpour 2 octets de plus en mettant f=devant le lambda.

Le programme Forth utilise un littéral à virgule flottante , qui doit être écrit en notation scientifique. Pi tronqué à 3 décimales ( 3.141) serait écrit comme ceci:

3141e-3

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

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

Renvoie le carré de l'entrée dans ES7 et la racine carrée dans ES6. Assez difficile à tester, sauf si vous avez un navigateur plus ancien qui supporte ES6 mais pas ES7.

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

console.log(f(4));

PHP et CJam , 30 29 25 octets

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

Calcule le carré en PHP et la racine carrée dans CJam. Doit être exécuté en utilisant -rPHP.

PHP

Lève le premier argument de ligne de commande ( $argv[1]) à la puissance 2 et le sort. Ici, il $argv[1]s'agit en réalité d'une variable en ligne dans une chaîne, qui est convertie en un nombre avant de procéder à l'exponentiation. En effet, ce vn'est pas une instruction valide dans CJam et entraînera une erreur lors de l'analyse, mais le placer dans une chaîne ne posera aucun problème.

# commence un commentaire, donc tout ce qui suit est ignoré.

Essayez-le en ligne!

CJam

La première partie du code ECHO"$argv[1]"**2;#contient de nombreuses valeurs et des opérations totalement inutiles. La seule chose importante est qu'ils ne génèrent aucune erreur, car ce qui est juste après ];, encapsule la pile entière dans un tableau, puis le rejette.

Après cela, il lit un double à partir de input ( rd), obtient sa racine carrée ( mq) et le sort implicitement.

Essayez-le en ligne!

C, langage de script Operation Flashpoint , 52 octets

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

Dans un script OFP, un point-virgule au début d'une ligne en fait un commentaire alors que C ne se soucie pas du point-virgule supplémentaire.

C:

Essayez-le en ligne!

Langage de script OFP:

Enregistrer sous init.sqsdans le dossier de mission, puis appelez-le avec hint format["%1", 2 call F].

Résultat:

Réticulaire / Befunge-98 , 15 octets

Langues 2D!

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

Befunge-98

/&:*.@

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

Réticulé

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

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

> <> / Jelly , 9 octets (code de 7 octets + 2 pour l'indicateur '-v' dans> <>)

Mec, je m'amuse vraiment avec la structure de liens Jelly.

:*n;
½

Calcule le carré dans> <> et la racine carrée dans Jelly .

Python 3 + JavaScript, 101 octets

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)

Racine carrée en JS, carrée en Python.

Fonctionne sur Firefox (testé sur FF 52) et nécessite (function(x) x)(42) === 42une syntaxe valide. Nécessite également ES7 pour l' **opérateur.

bash et sh, 48 octets

Mise à jour: je dois concéder la défaite. La réponse bash / sh de Digital Trauma est beaucoup plus élégante que celle-ci.

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

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

bcest seulement nécessaire pour sqrtpouvoir être calculé. La différence de comportement est entre bash et sh.

OK, techniquement, le "sh" que j'utilise est toujours bash, mais bash en mode "POSIX" (ce qui se produit si vous appelez /bin/shau lieu de /bin/bashsur des systèmes où /bin/shest un alias pour bash). Si tel est le cas sur votre système, vous pouvez tester avec:

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

Ceci est basé sur l'une des différences expliquées ici: https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html

QBIC / QBasic, 26 à 18 octets

input a
?a^2'^.25

En QBasic , il faut un nombre et l’imprime au carré. Le reste du code est ignoré car QBasic le considère comme un commentaire ( ').

QBIC utilise la même instruction d'entrée. Il a ensuite imprimé le même chiffre au carré, puis augmenté à la puissance d'un quart, ce qui l'a enraciné deux fois. En effet, il 'est considéré comme un littéral de code: code QBasic pur qui n’est pas analysé par QBIC.

Gelée / Pip , 6 octets

EDIT: C'est un octet plus court pour inverser les opérations.

RTa
²

Essayez Jelly en ligne!

Jelly commence l'exécution au bas du code (son "lien principal") et voit s'il a besoin de quelque chose de plus haut: il voit la commande se mettre en carré et prend en charge les entrées et les sorties de manière implicite.

Essayez Pip en ligne!

Pip exécute la ligne du haut, en quadrillant (variquement, implicitement, la ligne de commande) et en imprime implicitement. La ligne du bas est ignorée.

Wolfram Language / PHP , 25 octets

Obtenez le carré d'un nombre dans Wolfram Language et obtenez la racine carrée en PHP;

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

La première ligne est Wolfram Language. Tout d’abord, c’est à vous de changer n dans la barre de recherche de Wolfram Alpha pour que le code soit aussi l’entrée. Ensuite, vous obtiendrez la réponse en appuyant sur Entrée.

n^2

La deuxième ligne est PHP, elle donne la racine carrée du n à saisir dans la barre d’adresse (par exemple, ppcg.php.net?n=213, où 213 est la valeur de n)

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

PHP 5.6 et PHP 7, 55 octets

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

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

macOS Bash et sh, 24 octets

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

Sur le Mac, shest en bashcours d' exécution en mode Posix, et dans ce cas par https://www.gnu.org/software/bash/manual/html_node/Bash-POSIX-Mode.html :

Les instructions d'affectation précédant les commandes intégrées spéciales POSIX persistent dans l'environnement shell à l'issue de l'opération intégrée.

Ainsi, pour sh, la variable pa la valeur ^4après l' :exécution, mais pour elle bash, elle pn'a que cette valeur tant qu'elle :est exécutée, puis elle est vide.

Etant toujours bashsous la couverture, certains bashismes tels que <<<herestrings fonctionnent toujours pour les cas bash et sh.

Bash and Dash (et les utilitaires GNU), 27

Sur Ubuntu 16.01, shest un lien symbolique vers dash, qui ne fait pas son <<<anneau. Nous avons donc ceci à la place:

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

Essayez-le en ligne .

Octave / Cardinal , 28 octets

Ce programme place l’entrée dans Cardinal et obtient la racine carrée dans Octave

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

Essayez-le en ligne! (Octave)

Essayez-le en ligne! (Cardinal)

Donc,% est un commentaire d'une seule ligne dans Octave, de sorte qu'il est simplement saisi et affiche la racine

disp(sqrt(input("")))

Pour que le programme Cardinal ne rencontre pas d’erreur de division par 0 et meure, le programme

%:=t.

a été déplacé avec un espace, qui est ignoré par les deux programmes

Explication du programme Cardinal:

Le programme commence à la%
Il reçoit une entrée et stocke la valeur active:
Il définit l'inactif sur égal à l'actif =
il multiplie l'actif par l'inactif t.
Enfin, il émet la valeur active.

PHP / JavaScript, 43 octets

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

L'entrée va comme:

<?php $x = 10; ?>

Un peu explicite, mais est-ce que cela correspond aux règles? Mon premier code golf tho :-)

CGL (CGL Golfing Language) / JS (ES6), 13 octets (non compétitif)

Non compétitif parce que:

1. CGL a été libéré après cette question.
2. CGL n'est pas une langue valide . En raison de ＋et ⓟ, CGL est techniquement un langage valide.

Code:

 x=>x**2
//-₂

JS:

Simple: une fonction flèche anonyme qui retourne son premier argument au carré. Le code de langue sans nom est commenté.

CGL:

L' espace insécable avant la première ligne se comporte comme un commentaire. Les /s sont no-ops. La -deuxième ligne signifie décrémenter le numéro actuel de la pile, qui est 0 par défaut. Il est ensuite mis à -1, où l’entrée est stockée. Le ₂remplace le premier élément de la pile actuelle par sa racine carrée, qui est maintenant l'emplacement où l'entrée est placée. Par défaut, la pile actuelle est sortie, en sortie la racine carrée de l'entrée.