Bem, todo mundo adora poliglotas . Você receberá dois números inteiros, em qualquer forma padrão de entrada (sem codificação). Sua tarefa é escrever uma poliglota que encontre o valor mínimo em um idioma e o valor máximo entre os dois números no outro idioma e execute as seguintes operações:

• O código que encontra o valor máximo também deve calcular sua soma.
• O programa que encontrar o valor mínimo também deve calcular o resultado de sua subtração ( max - min)
• Aqui está a "parte complicada" : se os dois números forem iguais, os dois programas não devem produzir / retornar nada (para STDOUTe / STDERRou qualquer outro returnmétodo)
• Consulte a seção Especificações de saída para obter mais detalhes sobre a formatação.

Entrada

Como mencionado acima, dois números inteiros tomados como entrada em qualquer método padrão , comum aos dois idiomas.

Especificações de saída

• Para o programa que encontra o max, o formato deve ser:max_value, addition result
• Para o programa que encontra o min, o formato deve sermin_value, subtraction result (max - min)
• Os resultados podem ser impressos, com qualquer delimitador clara ( , \n, ,ou o que você quiser), retornado da função como uma string contendo os dois valores esperados com um delimitador ou como uma lista de números (por exemplo: [max_value,sum])

Exemplos:

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 

Pontuação:

Isso é código-golfe , portanto, tente escrever o código mais curto para obter os resultados desejados, observando que as brechas padrão são estritamente proibidas. Você deve usar dois idiomas diferentes, não outras versões do mesmo idioma (por exemplo: Python 2- Python 3pares não são válidos)

05AB1E / Jelly , 21 20 bytes

-1 byte depois de pedir ajuda - obrigado Emigna! ( `vai push(uwrapped(pop())))

Bytes brutos (o despejo à direita mostra o que minha máquina Windows exibe):

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

Ambos recebem entrada de STDIN e saída para STDOUT como uma representação de lista [x, y].

O idioma máximo é 05AB1E:

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

Onde os .bytes representados não podem ser impressos em sua página de código ( cp1252 ) e provavelmente aqui no que você estiver usando (0x18 = CANe 0x04 = EOT).

Experimente a versão 05AB1E

O idioma mínimo é Jelly:

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

Experimente a versão Jelly .

Quão?

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éia:

`Ȯ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 e C ++ (gcc), 117 107 bytes

-10 bytes graças 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);}

Explicação: Em C, auto c=.5declara uma variável inteira com a classe de armazenamento automático (que é o padrão), que é inicializada em 0, enquanto que em C ++ 11 declara um duplo, inicializado em 0,5. Portanto, o valor da variável será verdadeiro em C ++ e falso em C.

Idioma C - max: Experimente online!

C ++ - idioma mínimo: Experimente online!

Python 3 / Jelly , 42 bytes

Usando a página de código de Jelly para codificar o arquivo.

Bytes brutos:

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 definem uma função diádica sem nome.

Python (a linguagem máxima) vê:

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

Testes como Python .

Jelly (o idioma mínimo) vê:

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

Testes como geléia .

Quão?

Jelly interpreta 0x0a como ½, o átomo de raiz quadrada, enquanto Python interpreta como uma nova linha. No Jelly, 0x7f é interpretado como uma separação entre links (funções) e é representado por uma nova linha ou um pilcrow em sua página de código. Para o Jelly, o último link é a função principal - aqui ele não chama o link acima (que o intérprete ainda precisa analisar corretamente). No Python 0x23, #instrui que qualquer coisa após e antes de 0x0a, uma nova linha, é um comentário.

O código Python que é executado:

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

O código Jelly que é executado:

«,ạẋạṠ¥ - 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 retorna max / sum, Python retorna min / diferença. Entrada é um objeto de matriz lido de 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]])

Experimente on-line: Ruby

Experimente on-line: Python

A principal peculiaridade usada aqui é o uso da verdade 0no Ruby, que é falso no Python. A outra coisa que vale a pena mencionar é que a sortfunção do Python modifica a lista no local e retorna None, enquanto o Ruby não faz e retorna a matriz classificada, daí a necessidade de usarb or a para obter o mínimo / máximo.

O Python 3 é necessário porque o Python 2 reclama se você tentar chamar printapós a ordeclaração na última linha.

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));}}

Experimente online!

Java gera max e sum, AWK produz min e diferença. Nenhuma saída para se as entradas são idênticas.

Este é meu primeiro poliglota e primeiro 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
'*/

Baseado nesta solução minha de uma pergunta poliglota semelhante .

Essa solução também usa a abordagem de comentários!

JavaScript é o idioma min. Ele recebe uma matriz contendo números como entrada. Gera dois números separados por ,(1º número é o menor valor da matriz de entrada e 2º número é a diferença dos maiores e menores valores da matriz de entrada) por alert()ing. Não faz alert()nada se os números são iguais. Você pode chamar a função como f([100,40]).

QBasic é o idioma máximo. Solicita repetidamente a entrada, duas vezes. Imprime o maior número de números de entrada, bem como a soma dos números maiores e menores da entrada. Não faz PRINTnada se os números são iguais.

Como funciona?

No QBasic (um idioma da família BASIC estruturada; não requer números de linha), 'marca o início de um comentário que vai até o final da linha. Enquanto no JavaScript, ele marca o início de uma string. Portanto, a primeira linha inteira é marcada como um comentário no QBasic, mas no JavaScript, a linha é executada (e essa linha contém a parte do JavaScript que calcula o menor número e a diferença entre o maior e o menor número, além de um/* no final que inicia um comentário para ocultar o restante do código QBasic do interpretador JavaScript.)

O código da segunda linha para a segunda linha contém o código QBasic para calcular o maior número e a soma do maior e do menor número (o código é muito autoexplicativo).

A última linha contém '*/. 'faz com que o intérprete QBasic interprete o código a seguir como um comentário, enquanto que no JavaScript ele não tem nenhum efeito, pois faz parte de um comentário (iniciado no final da primeira linha). O código a seguir ( */) faz com que o JavaScript termine o comentário iniciado na primeira linha, mas não é executado no QBasic porque o QBasic acha que faz parte de um comentário.

Casos de teste

JavaScript (idioma 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 (idioma máximo):

Vá para este site . Copie e cole o seguinte código no 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 '*/

A razão pela qual os números de linha são necessários é que o site que mencionei suporta apenas idiomas BASIC não estruturados. E esse site é o único intérprete online do BASIC decente que eu pude encontrar. No entanto, a execução do código presente na parte superior da postagem (o código sem números de linha) deve funcionar bem em qualquer bom intérprete QBasic que ofereça suporte ao BASIC estruturado e 'como iniciador de comentários (poucos, no entanto, a maioria)