Bueno, a todos les encantan los políglotas . Se le darán dos enteros, en cualquier forma estándar de entrada (sin codificación). Su tarea es escribir un políglota que encuentre el valor mínimo en un idioma y el valor máximo entre los dos números en el otro idioma, y ​​realice las siguientes operaciones:

• El código que encuentra el valor máximo también debe calcular su suma.
• El programa que encuentra el valor mínimo también debe calcular el resultado de su resta ( max - min)
• Esta es la "parte difícil" : Si los dos números son iguales, tanto en los programas no deben de salida / retorno nada (ambos a STDOUTy STDERRo cualquier otro returnmétodo)
• Consulte la sección Especificaciones de salida para obtener más detalles sobre el formato.

Entrada

Como se indicó anteriormente, dos enteros se toman como entrada en cualquier método estándar , común a ambos idiomas.

Especificaciones de salida

• Para el programa que encuentra el max, el formato debe ser:max_value, addition result
• Para el programa que encuentra el min, el formato debe sermin_value, subtraction result (max - min)
• Los resultados se pueden imprimir, con cualquier delimitador clara ( , \n, ,o cualquier otra cosa que desee), devuelto por la función como una cadena que contiene los dos valores esperados con un delimitador o como una lista de números (por ejemplo: [max_value,sum])

Ejemplos:

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 

Puntuación:

Este es el código de golf , por lo tanto, intente escribir el código más corto para obtener los resultados deseados, mientras toma nota de que las lagunas estándar están estrictamente prohibidas. Debe usar dos idiomas diferentes, no otras versiones del mismo idioma (por ejemplo: Python 2- los Python 3pares no son válidos)

05AB1E / Jelly , 21 20 bytes

-1 byte después de pedir ayuda, ¡gracias Emigna! ( `voluntad push(uwrapped(pop())))

Bytes sin procesar (el volcado a la derecha muestra lo que muestra mi máquina Windows):

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

Ambos toman la entrada de STDIN y la salida a STDOUT como una representación de la lista [x, y].

El idioma máximo es 05AB1E:

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

Donde .representan los bytes no imprimibles en su página de códigos ( cp1252 ), y probablemente aquí en lo que sea que esté usando (0x18 = CANy 0x04 = EOT).

Prueba la versión 05AB1E

El idioma mínimo es Jelly:

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

Prueba la versión Jelly .

¿Cómo?

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

Jalea:

`Ȯ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 y C ++ (gcc), 117107 bytes

-10 bytes gracias a @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);}

Explicación: En C, auto c=.5declara una variable entera con la clase de almacenamiento automático (que es la predeterminada), que luego se inicializa a 0, mientras que en C ++ 11 declara un doble, que se inicializa a 0.5. Entonces el valor de la variable será verdadero en C ++ y falso en C.

C - max language: ¡ Pruébelo en línea!

C ++ - lenguaje mínimo: ¡ Pruébelo en línea!

Python 3 / Jelly , 42 bytes

Usando la página de códigos de Jelly para codificar el archivo.

Bytes sin procesar:

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                      .#.ú,Ó÷ÓÍ.

Ambos definen una función diádica sin nombre.

Python (el lenguaje máximo) ve:

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

Pruebas como Python .

Jelly (el lenguaje min) ve:

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

Pruebas como gelatina .

¿Cómo?

Jelly interpreta 0x0a como ½el átomo de raíz cuadrada, mientras que Python lo interpreta como una nueva línea. En Jelly 0x7f se interpreta como una separación entre enlaces (funciones) y está representado por una nueva línea o un pilcrow en su página de códigos. Para Jelly, el último enlace es la función principal: aquí no llama al enlace anterior (que el intérprete aún necesita analizar correctamente). En Python 0x23, #indica que todo lo que esté después y antes de 0x0a, una nueva línea, es un comentario.

El código de Python que se ejecuta:

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

El código Jelly que se ejecuta:

«,ạẋạṠ¥ - 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 bytes

Ruby devuelve máximo / suma, Python devuelve mínimo / diferencia. La entrada es un objeto de matriz leído desde 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]])

Pruébelo en línea: Ruby

Pruébelo en línea: Python

La peculiaridad principal utilizada aquí es el uso de la verdad 0en Ruby, que es falsa en Python. La otra cosa que vale la pena mencionar es que la sortfunción de Python modifica la lista en el lugar y devuelve None, mientras que Ruby no lo hace y devuelve la matriz ordenada, de ahí la necesidad de usar b or apara obtener el mínimo / máximo.

Se requiere Python 3 porque Python 2 se queja si intenta llamar printdespués de la ordeclaración en la última línea.

Java / AWK , 219 217 212 196 bytes

/*#\/* /
{$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));}}

Pruébalo en línea!

Java genera el máximo y la suma, AWK genera el mínimo y la diferencia. No hay salida para ninguno si las entradas son idénticas.

Este es mi primer políglota y primer TIO :)

JavaScript (ES6) / QBasic, 172 171 bytes

'';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
'*/

Basado en esta solución mía de una pregunta políglota similar .

¡Esta solución también usa el enfoque de comentarios!

JavaScript es el lenguaje min. Toma una matriz que contiene números como entrada. Emite dos números separados por ,(el primer número es el valor más pequeño de la matriz de entrada y el segundo número es la diferencia de los valores más grande y más pequeño de la matriz de entrada) por alert()ing. No hace alert()nada si los números son iguales. Puedes llamar a la función como f([100,40]).

QBasic es el lenguaje máximo. Repetidamente pide información, dos veces. Imprime el número más grande de los números de entrada, así como la suma de los números más grandes y más pequeños de la entrada. No hace PRINTnada si los números son iguales.

¿Como funciona?

En QBasic (un lenguaje de familia BASIC estructurada; no requiere números de línea), 'marca el comienzo de un comentario que va hasta el final de la línea. Mientras que en JavaScript, marca el inicio de una cadena. Entonces, toda la primera línea está marcada como un comentario en QBasic pero en JavaScript, la línea se ejecuta (y esta línea contiene la parte de JavaScript que calcula el número más pequeño y la diferencia de los números más grandes y más pequeños, así como un /*al final que comienza un comentario para ocultar el resto del código QBasic del intérprete de JavaScript).

El código de la segunda línea a la última línea contiene el código QBasic para calcular el número mayor y la suma del número mayor y menor (el código se explica por sí mismo).

La última línea contiene '*/. 'hace que el intérprete de QBasic interprete el siguiente código como un comentario, mientras que en JavaScript no tiene ningún efecto ya que es parte de un comentario (que se inició al final de la primera línea). El siguiente código ( */) hace que JavaScript finalice el comentario que se inició en la primera línea, pero no se ejecuta en QBasic porque QBasic cree que es parte de un comentario.

Casos de prueba

JavaScript (lenguaje mínimo):

'';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-language):

Ve a este sitio web . Copie y pegue el siguiente código en su editor de texto:

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 razón por la cual se requieren números de línea es que el sitio web que mencioné solo admite idiomas BASIC no estructurados. Y ese sitio web es el único intérprete BASIC en línea decente que pude encontrar. Sin embargo, ejecutar el código presente en la parte superior de la publicación (el código sin números de línea) debería funcionar bien en cualquier buen intérprete de QBasic que admita BASIC estructurado y 'como iniciador de comentarios (aunque pocos no, la mayoría sí)