Scrivi un programma o una funzione che accetta due numeri interi che rappresentano le coordinate X e Y di un punto su un piano cartesiano .

L'ingresso può venire in qualsiasi formato ragionevole finché il valore X viene prima Y. Ad esempio, 1 -2, (1,-2), [1, -2], o 1\n-2sarebbero tutti bene per X = 1, Y = -2.

Stampa o restituisce una stringa di singoli caratteri (seguita da una nuova riga finale facoltativa) che descrive la posizione del punto nel piano:

• 1se il punto è nel quadrante I
• 2 se il punto è nel quadrante II
• 3 se il punto è nel quadrante III
• 4 se il punto è nel quadrante IV
• Xse il punto si trova sull'asse x (la minuscola xnon è consentita)
• Yse il punto si trova sull'asse y (la minuscola ynon è consentita)
• O se il punto è sull'origine (è una lettera maiuscola "oh", non zero)

Vince il codice più breve in byte. Tiebreaker va alla risposta più votata.

Casi test

(1,-2) -> 4
(30,56) -> 1
(-2,1) -> 2
(-89,-729) -> 3
(-89,0) -> X
(0,400) -> Y
(0,0) -> O
(0,1) -> Y
(0,-1) -> Y
(1,0) -> X
(-1,0) -> X
(1,1) -> 1
(1,-1) -> 4
(-1,1) -> 2
(-1,-1) -> 3

Gelatina, 14 byte

Ṡḅ3ị“Y4X13X2YO

Provalo online!

Come funziona

Ṡḅ3ị“Y4X13X2YO    Main link. Input: [x, y]

Ṡ                 Apply the sign function to both coordinates.
 ḅ3               Convert the resulting pair from base 3 to integer.
                  Because of how base conversion is implemented in Jelly, this maps
                  [a, b] to (3a + b), even if a and b aren't valid ternary digits.
                  Therefore:
                      [0, 1]   ->  1
                      [1, -1]  ->  2
                      [1, 0]   ->  3
                      [1, 1]   ->  4
                      [-1, -1] -> -4
                      [-1, 0]  -> -3
                      [-1, 1]  -> -2
                      [0, -1]  -> -1
                      [0, 0]   ->  0
   ị“Y4X13X2YO    Retrieve the character at that index from the string.
                Indexing is 1-based and modular in Jelly, so 1ị retrieves the
                first character, -1ị the penultimate, and 0ị the last.

Rubino, 35 byte

->x,y{%w[OY X14 X23][x<=>0][y<=>0]}

Sfruttando l' <=>operatore "astronave" ( ).

x <=> 0 sarà di ritorno

• 0 Se x == 0
• 1 Se x > 0
• -1 Se x < 0

Quindi,

• se x == 0, torniamo 'OY'[y<=>0]. Questo è

  • Oif y == 0(indicizzazione stringa in 0)

  • Yif y != 0(questo è vero perché entrambi 1e -1comporteranno l' Yindicizzazione su questa stringa, come si -1riferisce all'ultimo carattere nella stringa, che è anche quello nell'indice 1)

• se x > 0, torniamo 'X14'[y<=>0]. Questo è Xse y == 0, 1se y > 0e 4se y < 0(vedere la spiegazione sopra).

• se x < 0, torniamo 'X23'[y<=>0].

JavaScript, 44 byte

(x,y)=>x?y?x>0?y>0?1:4:y>0?2:3:'X':y?'Y':'O'

f=(x,y)=>x?
            y?
                x>0?
                    y>0?1
                    :4
                :y>0?2:3
            :'X'
        :y?'Y':'O'

document.body.innerHTML = '<pre>' +
    'f(1,-2) -> ' + f(1,-2) + '<br>' +
    'f(30,56) -> ' + f(30,56) + '<br>' +
    'f(-2,1) -> ' + f(-2,1) + '<br>' +
    'f(-89,-729) -> ' + f(-89,-729) + '<br>' +
    'f(-89,0) -> ' + f(-89,0) + '<br>' +
    'f(0,400) -> ' + f(0,400) + '<br>' +
    'f(0,0) -> ' + f(0,0) + '<br>' +
    'f(0,1) -> ' + f(0,1) + '<br>' +
    'f(0,-1) -> ' + f(0,-1) + '<br>' +
    'f(1,0) -> ' + f(1,0) + '<br>' +
    'f(-1,0) -> ' + f(-1,0) + '<br>' +
    'f(1,1) -> ' + f(1,1) + '<br>' +
    'f(1,-1) -> ' + f(1,-1) + '<br>' +
    'f(-1,1) -> ' + f(-1,1) + '<br>' +
    'f(-1,-1) -> ' + f(-1,-1) + '<br>' +
'</pre>';

ES6, 43 byte

(x,y)=>"OYYX32X41"[3*!!x+3*(x>0)+!!y+(y>0)]

Un intero byte più corto di tutti quei ternari!

Japt, 30 22 byte

"3Y2XOX4Y1"g4+3*Ug +Vg

Ispirato dalla risposta Jelly di @Dennis prima di aggiungere una spiegazione. Provalo online!

Curiosità: questo sarebbe più corto di due byte se avessi aggiunto il supporto per i numeri negativi nella gfunzione per le stringhe.

Un altro tentativo, più vicino a quello Jelly (23 byte):

"3Y2XOX4Y1"gNmg m+1 ¬n3

Purtroppo, incrementare un elenco costa 4 byte ...

MATL , 22 byte

'3X2YOY4X1'iZSQI1h*sQ)

Questo utilizza l' attuale versione (10.2.1) del linguaggio / compilatore.

Provalo online!

Spiegazione

Ciò prende spudoratamente in prestito il grande approccio nella risposta di Dennis .

'3X2YOY4X1'     % literal string. Will be indexed into to produce result
i               % input array of two numbers
ZS              % sign of each number in that array. Gives -1, 0 or 1
Q               % add 1 to produce 0, 1 or 2
I1h             % array [3 1]
*s              % multiply both arrays element-wise and compute sum
Q               % add 1. Gives a value from 1 to 9
)               % index into string. Display

Pyth, 18 byte

@"OY4X13X2Y"i._RQ3

Spiegazione:

                   - Autoassign Q = eval(input())
             ._RQ  - map(cmp, Q)
            i    3 - convert to base 3
@"OY4X13X2Y"       - "OY4X13X2Y"[^] (A lookup table)

Provalo qui.

O l'intera suite di test

Python 2, 75 byte

lambda x,y,b=bool:[['OX','YO'][b(y)][b(x)],[[1,2],[4,3]][y<0][x<0]][b(x*y)]

Abbastanza diretto.

Mathematica 81 byte

Switch[Sign@#,{1,-1},4,{1,1},1,{-1,1},2,{-1,-1},3,{0,0},"O",{_,0},"X",{0,_},"Y"]&

%/@{{1, -2}, {30, 56}, {-2, 1}, {-89, -729}, {-89, -0}, {0, 400}, {0, 0},{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}}

{4, 1, 2, 3, "X", "Y", "O", "Y", "Y", "X", "X", 1, 4, 2, 3}

Retina , 52

Questo è un semplice metodo basato sulla sostituzione:

^0 0
O
^0.*
Y
.* 0
X
-.*-.*
3
^-.*
2
.*-.*
4
.* .*
1

Provalo online . Il supplemento m`all'inizio di alcune righe è necessario solo per testare più input in una volta, quindi non vengono conteggiati nel punteggio.

In precedenza ho provato questo approccio più interessante , ma è un po 'più lungo (circa 65 senza i mmodificatori):

[1-9]\d*
1
-1
2
(.) (.)
$1$*3$2$*1
3
111
m`^(.)*$
$#1
T`d`OYYX14X23

• sostituire tutti i numeri diversi da zero 1, lasciando -in posizione i segni
• Sostituire -1con2
• Converti 1o e 2o numero unari con 3e 1rispettivamente come cifre unarie. Questo dà effettivamente 2 cifre di base3, espresse in unario
• Converti in 3s in 111. Ciò fornisce effettivamente un unico numero unario che corrisponde a ciascuno dei quadranti, degli assi e dell'origine
• Converti unario in una cifra decimale
• Trasporre la cifra decimale sul carattere di output appropriato.

Ottava, 34 byte

@(p)['3X2YOY4X1'](sign(p)*[3;1]+5)

Il vecchio trucco base-3 attraverso la moltiplicazione vettoriale (anche se ho dovuto aggiungere 5 per tenere conto degli indici di array basati su 1) più un po 'di magia di indicizzazione di Ottava.

L'input è un vettore del modulo [1, -2](con o senza la virgola), quindi quando assegnato a una variabile w:

>> w([1 -2])
ans = 4

Eccolo su ideone .

Pyth, 24

Troppo lungo, ma forse un approccio interessante:

?Q?sQ?eQh%/yPQ.n04\X\Y\O

L'ingresso deve essere specificato come un numero complesso, ad es 1-2j. Fondamentalmente un ternario nidificato per testare:

• se input è zero - output O
• altrimenti se la parte reale è zero - output Y
• altrimenti se la parte immaginaria è zero - output X
• altrimenti calcola la fase complessa, moltiplica per 2, dividi interi per π, quindi mod e aggiungi per dare il numero di quadrante appropriato.

Provalo online.

Java 8, 64 byte

questa è un'espressione lambda per a BiFunction<Integer,Integer,String>.

(x,y)->"OYYX14X23".charAt(3*(x>0?1:x<0?2:0)+(y>0?1:y<0?2:0))+"";

3 byte potrebbero essere salvati restituendo un Characterinvece di un Stringma non sono del tutto sicuro se l'autoboxing giocherà bene con la lambda.