Bene, tutti amano i poliglotti . Ti verranno dati due numeri interi, in qualsiasi forma standard di input (nessun hardcoding). Il tuo compito è scrivere un poliglotta che trovi il valore minimo in una lingua e il valore massimo tra i due numeri nell'altra lingua ed esegua le seguenti operazioni:

• Il codice che trova il valore massimo deve anche calcolare la loro somma.
• Il programma che trova il valore minimo deve anche calcolare il risultato della loro sottrazione ( max - min)
• Ecco il "trucchetto" : Se i due numeri sono uguali, entrambi i programmi non devono in uscita / ritorno nulla (sia per STDOUTe STDERRo qualsiasi altro returnmetodo)
• Consulta la sezione Specifiche di output per maggiori dettagli sulla formattazione

Ingresso

Come detto sopra, due numeri interi presi come input in qualsiasi metodo standard , comune a entrambe le lingue.

Specifiche di uscita

• Per il programma che trova il max, il formato dovrebbe essere:max_value, addition result
• Per il programma che trova il min, il formato dovrebbe esseremin_value, subtraction result (max - min)
• I risultati possono essere stampati, con qualsiasi delimitatore chiaro ( , \n, ,o qualsiasi altra cosa che si desidera), restituito dalla funzione come una stringa contenente i due valori attesi con un delimitatore o come un elenco di numeri (es: [max_value,sum])

Esempi:

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 

punteggio:

Questo è code-golf , quindi prova a scrivere il codice più breve per ottenere i risultati desiderati, tenendo presente che le scappatoie standard sono severamente vietate. È necessario utilizzare due lingue diverse, non altre versioni della stessa lingua (ad esempio: Python 2- le Python 3coppie non sono valide)

05AB1E / Jelly , 21 20 byte

-1 byte dopo aver chiesto aiuto - grazie Emigna! ( `volontà push(uwrapped(pop())))

Byte non elaborati (il dump a destra mostra ciò che visualizza il mio computer Windows):

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

Entrambi accettano input da STDIN e output su STDOUT come rappresentazione di elenco [x, y].

La lingua massima è 05AB1E:

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

Dove .rappresenta i byte non stampabili nella sua tabella codici ( cp1252 ), e probabilmente qui in qualunque cosa tu stia usando (0x18 = CANe 0x04 = EOT).

Prova la versione 05AB1E

La lingua minima è Jelly:

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

Prova la versione Jelly .

Come?

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

Gelatina:

`Ȯ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 byte

-10 byte grazie 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);}

Spiegazione: In C, auto c=.5dichiara una variabile intera con la classe di memorizzazione automatica (che è l'impostazione predefinita), che viene quindi inizializzata su 0, mentre in C ++ 11 dichiara un doppio, che viene inizializzato su 0,5. Quindi il valore della variabile sarà veritiero in C ++ e falso in C.

C - max lingua: provalo online!

C ++ - linguaggio minimo: provalo online!

Python 3 / Jelly , 42 byte

Utilizzando la code-page di Jelly per codificare il file.

Byte non elaborati:

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

Entrambi definiscono una funzione diadica senza nome.

Python (la lingua massima) vede:

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

Test come Python .

Jelly (la lingua minima) vede:

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

Test come Jelly .

Come?

Jelly interpreta 0x0a come ½, l'atomo di radice quadrata mentre Python lo interpreta come una nuova riga. In Jelly 0x7f è interpretato come una separazione tra collegamenti (funzioni) ed è rappresentato da una nuova riga o da una carta da lettere nella sua tabella codici. Per Jelly l'ultimo link è la funzione principale - qui non chiama il link sopra (che l'interprete deve ancora analizzare correttamente). In Python 0x23, #indica che qualsiasi cosa dopo e prima di 0x0a, una nuova riga, è un commento.

Il codice Python che viene eseguito:

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

Il codice Jelly che viene eseguito:

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

Ruby restituisce max / sum, Python restituisce min / differenza. L'input è un oggetto array letto da 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]])

Provalo online: Ruby

Provalo online: Python

La stranezza usata qui è l'uso della verità 0in Ruby, che è falsa in Python. L'altra cosa degna di nota è che la sortfunzione di Python modifica l'elenco sul posto e restituisce None, mentre Ruby non lo fa e restituisce l'array ordinato, quindi la necessità di usareb or a per ottenere il min / max.

Python 3 è necessario perché Python 2 si lamenta se si tenta di chiamare printdopo l' oristruzione nell'ultima riga.

Java / AWK , 219 217 212 196 byte

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

Provalo online!

Java genera il massimo e la somma, AWK produce il minimo e la differenza. Nessuna uscita per entrambi se gli ingressi sono identici.

Questo è il mio primo poliglotta e il primo TIO :)

JavaScript (ES6) / QBasic, 172 171 byte

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

Sulla base di questa mia soluzione di una domanda poliglotta simile .

Anche questa soluzione usa l'approccio al commento!

JavaScript è la lingua minima. Accetta un array contenente numeri come input. Emette due numeri separati da ,(il 1o numero è il valore più piccolo dell'array di input e il 2o numero è la differenza del valore più grande e più piccolo dell'array di input) alert()ing. Non fa alert()nulla se i numeri sono uguali. È possibile chiamare la funzione come f([100,40]).

QBasic è la lingua massima. Chiede ripetutamente input, due volte. Stampa il numero più grande dei numeri di input, nonché la somma dei numeri più grandi e più piccoli dell'input. Non fa PRINTnulla se i numeri sono uguali.

Come funziona?

In QBasic (un linguaggio della famiglia BASIC strutturata; non richiede numeri di riga), 'segna l'inizio di un commento che arriva fino alla fine della riga. Considerando che in JavaScript, segna l'inizio di una stringa. Quindi, l'intera prima riga è contrassegnata come un commento in QBasic ma in JavaScript, la riga viene eseguita (e questa riga contiene la parte JavaScript che calcola il numero più piccolo e la differenza dei numeri più grandi e più piccoli, nonché un/* alla fine che avvia un commento per nascondere il resto del codice QBasic all'interprete JavaScript.)

Il codice dalla seconda all'ultima riga contiene il codice QBasic per calcolare il numero più grande e la somma del numero più grande e più piccolo (il codice è molto autoesplicativo).

L'ultima riga contiene '*/. 'fa sì che l'interprete QBasic interpreti il ​​seguente codice come un commento, mentre in JavaScript non ha alcun effetto in quanto fa parte di un commento (che è stato avviato alla fine della prima riga). Il codice seguente ( */) fa sì che JavaScript termini il commento che è stato avviato nella prima riga, ma non viene eseguito in QBasic perché QBasic pensa che sia parte di un commento.

Casi test

JavaScript (lingua minima):

'';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 (lingua massima):

Vai a questo sito Web . Copia incolla il seguente codice nel loro editor di testo:

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

Il motivo per cui sono richiesti i numeri di riga è che il sito Web che ho citato supporta solo lingue BASIC non strutturate. E quel sito web è l'unico interprete BASIC online decente che ho trovato. Tuttavia, eseguire il codice presente nella parte superiore del post (il codice senza numeri di riga) dovrebbe funzionare bene in qualsiasi buon interprete QBasic che supporti BASIC strutturato e 'come commentatore (pochi però, la maggior parte lo fanno, però)