Eh bien, tout le monde aime les polyglottes . Vous recevrez deux entiers, dans n'importe quelle forme d'entrée standard (pas de codage en dur). Votre tâche consiste à écrire un polyglotte qui trouve la valeur minimale dans une langue et la valeur maximale entre les deux nombres dans l'autre langue, et effectue les opérations suivantes:

• Le code qui trouve la valeur maximale doit également calculer leur somme.
• Le programme qui trouve la valeur minimale doit également calculer le résultat de leur soustraction ( max - min)
• Voici la "partie délicate" : si les deux nombres sont égaux, les deux programmes ne doivent rien produire / renvoyer (à la fois vers STDOUTet STDERRou toute autre returnméthode)
• Voir la section Spécifications de sortie pour plus de détails sur le formatage

Contribution

Comme indiqué ci-dessus, deux entiers pris en entrée dans toute méthode standard , communs aux deux langues.

Spécifications de sortie

• Pour le programme qui trouve le max, le format doit être:max_value, addition result
• Pour le programme qui trouve le min, le format doit êtremin_value, subtraction result (max - min)
• Les résultats peuvent être imprimés, avec un delimiter clair ( , \n, ,ou tout ce que vous voulez), renvoyée par la fonction comme une chaîne contenant les deux valeurs attendues avec un séparateur ou une liste de numéros (par exemple: [max_value,sum])

Exemples:

Input   || Max Language Output || Min Language Output

100, 40 || 100, 140            || 40, 60
63, 67  || 67, 130             || 63, 4
-45, -5 || -5, -50             || -45, 40
21, 21  ||                     ||
-1, 1   || 1, 0                || -1, 2 

Notation:

Il s'agit de code-golf , essayez donc d'écrire le code le plus court pour obtenir les résultats souhaités, tout en prenant note que les échappatoires standard sont strictement interdites. Vous devez utiliser deux langues différentes, pas d'autres versions de la même langue (par exemple: Python 2- les Python 3paires ne sont pas valides)

05AB1E / Jelly , 21 20 octets

-1 octet après avoir demandé de l'aide - merci Emigna! ( `va push(uwrapped(pop())))

Octets bruts (le vidage à droite montre ce que ma machine Windows affiche):

60 ca 69 b9 5a 73 4f 29 71 93 18 fa 2c d3 f7 d3    `Êi¹ZsO)q..ú,Ó÷Ó
cd 04 18 2f                                         Í../

Les deux prennent l'entrée de STDIN et la sortie vers STDOUT comme une représentation de liste [x, y].

La langue maximale est 05AB1E:

`Êi¹ZsO)q“.ú,Ó÷ÓÍ../

Où les .représentent les octets non imprimables dans sa page de codes ( cp1252 ), et probablement ici dans tout ce que vous utilisez (0x18 = CANet 0x04 = EOT).

Essayez la version 05AB1E

La langue min est Jelly:

İ__iỤZs0)qƓð«,ạẋạṠ¥ð/

Essayez la version Jelly .

Comment?

05AB1E:

`Êi¹ZsO)q“.ú,Ó÷ÓÍ../ - parsed left to right, executed as parsed
                     - implicit input taken
  i                  - If:
`                    -     push(unwrapped(pop()))
 Ê                   -     push(pop()!=pop())
                     - ...Then:
   ¹                 -     push(1st item from input history)
    Z                -     push(max(top of stack))
     s               -     push(reverse(pop(),pop()))
      O              -     push(sum(pop()))
       )             -     wrap(pop())
        q            -     quit - implicit print of top of stack
         “.ú,Ó÷ÓÍ../ - unexecuted and unparsed string

Gelée:

`ȮiỤZs0)qƓð«,ạẋạṠ¥ð/ - parsed left to right, not executed until parsed
`ȮiỤZs0              - a dyadic chain which would error if executed (monad from dyad, index of, grade up, transpose, split into chunks of length 0)
       )q            - currently unassigned code points each currently creates a new link
         Ɠ           - read and evaluate a line of input
          ð       ð  - dyadic chain separations
                   / - reduce by:
           «         -     minimum(left, right)
             ạ       -     absolute difference(left, right)
            ,        -     pair(result)
                 ¥   -     last two links as a dyad:
               ạ     -         absolute difference(left, right)
                Ṡ    -         sign(result) (i.e. {0:0, +x:1, -x:-1} but -x never happens)
              ẋ      -     repeat list left right times
                     - implicit print

C et C ++ (gcc), 117 107 octets

-10 octets grâce à @Steadybox!

#include<stdio.h>
int f(int a,int b){auto c=.5;a-b&&printf("%d %d",c?b<a?b:a:a>b?a:b,c?a-b>0?a-b:b-a:a+b);}

Explication: En C, auto c=.5déclare une variable entière avec la classe de stockage automatique (qui est la valeur par défaut), qui est ensuite initialisée à 0, tandis qu'en C ++ 11, elle déclare un double, qui est initialisé à 0,5. Ainsi, la valeur de la variable sera véridique en C ++ et fausse en C.

Langue C - max: Essayez-la en ligne!

C ++ - langage min: essayez-le en ligne!

Python 3 / Jelly , 42 octets

Utiliser la page de codes de Jelly pour encoder le fichier.

Octets bruts:

6c 61 6d 62 64 61 20 78 2c 79 3a 5b 6d 61 78 28    lambda x,y:[max(
78 2c 79 29 2c 78 2b 79 5d 2a 28 78 21 3d 79 29    x,y),x+y]*(x!=y)
0a 23 7f fa 2c d3 f7 d3 cd 04                      .#.ú,Ó÷ÓÍ.

Les deux définissent une fonction dyadique sans nom.

Python (le langage max) voit:

lambda x,y:[max(x,y),x+y]*(x!=y)
#\x7fú,Ó÷ÓÍ\x04

Tests en Python .

Jelly (la langue min) voit:

lambda x,y:[max(x,y),x+y]*(x!=y)½#
«,ạẋạṠ¥

Tests en gelée .

Comment?

Jelly interprète 0x0a comme ½l'atome de racine carrée tandis que Python l'interprète comme une nouvelle ligne. Dans Jelly 0x7f est interprété comme une séparation entre les liens (fonctions) et est représenté par une nouvelle ligne ou un pilcrow dans sa page de codes. Pour Jelly, le dernier lien est la fonction principale - ici, il n'appelle pas le lien ci-dessus (que l'interprète doit encore analyser correctement). En Python 0x23, #indique que tout ce qui se trouve après et avant 0x0a, une nouvelle ligne, est un commentaire.

Le code Python qui est exécuté:

lambda x,y:[max(x,y),x+y]*(x!=y)
lambda x,y:                      - A function taking two inputs, x and y
           [        ,   ]        - A list with two items
            max(x,y)             - take the maximum of x and y
                     x+y         - x plus y
                           x!=y  - x not equal to y?
                         *(    ) - multiply - True is treated as if it were 1, False as if it were 0

Le code Jelly qui s'exécute:

«,ạẋạṠ¥ - A dyadic link (function of two variables): x, y
«       - minimum(x, y)
  ạ     - absolute difference(x, y)
 ,      - pair left with right (creating a list)
      ¥ - last two links as a dyad:
     ạ  -     absolute difference(x, y)
    Ṡ   -     sign(result) (i.e. {0:0, +x:1, -x:-1} but -x never happens)
   ẋ    - repeat the list to the left right times (either the same list or an empty list)
        - return the result

Ruby / Python 3, 102 octets

Ruby renvoie max / sum, Python renvoie min / difference. L'entrée est un objet tableau lu depuis STDIN.

a=eval((0and gets or input()))
b=a.sort()
x,y=(b or a)
z=0 or 1
x==y or print([[y,x][z],[x+y,y-x][z]])

Essayez-le en ligne: Ruby

Essayez-le en ligne: Python

La principale bizarrerie utilisée ici est l'utilisation de la vérité 0en Ruby, qui est fausse en Python. L'autre chose à noter est que la sortfonction de Python modifie la liste sur place et retourne None, tandis que Ruby ne le fait pas et retourne le tableau trié, d'où la nécessité d'utiliser b or apour obtenir le min / max.

Python 3 est requis car Python 2 se plaint si vous essayez d'appeler printaprès l' orinstruction dans la dernière ligne.

Java / AWK , 219 217 212 196 octets

/*#\/* /
{$0=((x=$1)<y=$2)?x" "y-x:y" "x-y}x!=y
#*/interface B{static void main(String[]A){Integer x=Integer.parseInt(A[0]);int y=x.parseInt(A[1]);System.out.print(x==y?"":(x<y?y:x)+" "+(x+y));}}

Essayez-le en ligne!

Java sort le max et la somme, AWK sort le min et la différence. Pas de sortie non plus si les entrées sont identiques.

Ceci est mon premier polyglotte et mon premier TIO :)

JavaScript (ES6) / QBasic, 172 171 octets

'';f=x=>{m=Math.max(...x);s=Math.min(...x);if(x[0]!=x[1])alert([m,m-s])}/*
INPUT c
LET m=c
LET s=c
INPUT n
IF n>c THEN m=n
IF n<c THEN s=n
IF n<>c THEN PRINT m,m+s
END
'*/

Basé sur ma solution d'une question polyglotte similaire .

Cette solution utilise également l'approche des commentaires!

JavaScript est le min-langage. Il prend en entrée un tableau contenant des nombres. Génère deux nombres séparés par ,(le premier nombre est la plus petite valeur du tableau d'entrée et le deuxième nombre est la différence entre la plus grande et la plus petite valeur du tableau d'entrée) par alert()ing. N'a alert()rien si les nombres sont égaux. Vous pouvez appeler la fonction comme f([100,40]).

QBasic est la langue max. Demande à plusieurs reprises des commentaires, deux fois. Imprime le plus grand nombre de numéros d'entrée ainsi que la somme des plus grands et des plus petits nombres de l'entrée. N'a PRINTrien si les nombres sont égaux.

Comment ça marche?

Dans QBasic (un langage de la famille BASIC structurée; il ne nécessite pas de numéros de ligne), 'marque le début d'un commentaire qui va jusqu'à la fin de la ligne. Alors qu'en JavaScript, il marque le début d'une chaîne. Ainsi, toute la première ligne est marquée comme un commentaire dans QBasic mais en JavaScript, la ligne est exécutée (et cette ligne contient la partie JavaScript qui calcule le plus petit nombre et la différence des plus grands et des plus petits nombres, ainsi qu'un /*à la fin qui démarre un commentaire afin de masquer le reste du code QBasic de l'interpréteur JavaScript.)

Le code de la deuxième ligne à l'avant-dernière ligne contient le code QBasic pour calculer le plus grand nombre et la somme du plus grand et du plus petit nombre (le code est très explicite).

La dernière ligne contient '*/. 'fait que l'interpréteur QBasic interprète le code suivant comme un commentaire, alors qu'en JavaScript, il n'a aucun effet car il fait partie d'un commentaire (qui a été démarré à la fin de la première ligne). Le code suivant ( */) oblige JavaScript à terminer le commentaire qui a été démarré dans la première ligne, mais il n'est pas exécuté dans QBasic car QBasic pense qu'il fait partie d'un commentaire.

Cas de test

JavaScript (min-langue):

'';f=x=>{m=Math.max(...x);s=Math.min(...x);if(x[0]!=x[1])alert([m,m-s])}/*
INPUT c
LET m=c
LET s=c
INPUT n
IF n>c THEN m=n
IF n<c THEN s=n
IF n<>c THEN PRINT m,m+s
END
'*/

f([100,40]);

QBasic (max-langue):

Accédez à ce site Web . Copiez collez le code suivant dans leur éditeur de texte:

1 '';f=x=>{m=Math.max(...x);s=Math.min(...x);if(x[0]!=x[1])alert([m,m-s])}/*
2 INPUT c
3 LET m=c
4 LET s=c
5 INPUT n
6 IF n>c THEN m=n
7 IF n<c THEN s=n
8 IF n<>c THEN PRINT m,m+s
9 END
10 '*/

La raison pour laquelle les numéros de ligne sont requis est que le site Web que j'ai mentionné ne prend en charge que les langues BASIC non structurées. Et ce site Web est le seul interprète BASIC en ligne décent que j'ai pu trouver. Cependant, l'exécution du code présent en haut de la publication (le code sans numéros de ligne) devrait fonctionner correctement dans tout bon interpréteur QBasic qui prend en charge le BASIC structuré et en 'tant que démarreur de commentaires (peu le font pas, la plupart le font cependant)