Écrivez un programme ou une fonction qui prend deux entiers qui représentent les coordonnées X et Y d'un point sur un plan cartésien .

L'entrée peut venir dans tout format raisonnable, tant que la valeur de X est avant Y. Par exemple, 1 -2, (1,-2), [1, -2]ou 1\n-2tout serait bien pour X = 1, Y = -2.

Imprimez ou renvoyez une chaîne de caractères unique (suivie d'un retour à la ligne facultatif) qui décrit l'emplacement du point dans le plan:

• 1si le point est dans le quadrant I
• 2 si le point est dans le quadrant II
• 3 si le point est dans le quadrant III
• 4 si le point est dans le quadrant IV
• Xsi le point est sur l'axe des x (les minuscules xne sont pas autorisées)
• Ysi le point est sur l'axe des y (les minuscules yne sont pas autorisées)
• O si le point est sur l'origine (c'est une lettre majuscule "oh", pas zéro)

Le code le plus court en octets gagne. Tiebreaker passe à la réponse la plus élevée.

Cas de 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

Gelée, 14 octets

Ṡḅ3ị“Y4X13X2YO

Essayez-le en ligne!

Comment ça marche

Ṡḅ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.

Rubis, 35 octets

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

Tirer parti de l' <=>opérateur "vaisseau spatial" ( ).

x <=> 0 reviendra

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

Par conséquent,

• si x == 0, nous revenons 'OY'[y<=>0]. C'est

  • Oif y == 0(indexation des chaînes à 0)

  • Yif y != 0(ceci est vrai car les deux 1et -1se traduiront Ylors de l'indexation sur cette chaîne, comme -1fait référence au dernier caractère de la chaîne, qui se trouve également être celui de l'index 1)

• si x > 0, nous revenons 'X14'[y<=>0]. C'est Xsi y == 0, 1si y > 0et 4si y < 0(voir l'explication ci-dessus).

• si x < 0, nous revenons 'X23'[y<=>0].

JavaScript, 44 octets

(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 octets

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

Un octet entier plus court que tous ces ternaires!

Japt, 30 22 octets

"3Y2XOX4Y1"g4+3*Ug +Vg

Inspiré par la réponse de @Dennis 'Jelly avant d'ajouter une explication. Testez-le en ligne!

Fait amusant: ce serait deux octets plus court si j'avais ajouté la prise en charge des nombres négatifs dans la gfonction pour les chaînes.

Une autre tentative, plus proche de celle de Jelly (23 octets):

"3Y2XOX4Y1"gNmg m+1 ¬n3

Malheureusement, incrémenter une liste coûte 4 octets ...

MATL , 22 octets

'3X2YOY4X1'iZSQI1h*sQ)

Cela utilise la version actuelle (10.2.1) du langage / compilateur.

Essayez-le en ligne!

Explication

Cela emprunte sans vergogne la grande approche de la réponse de 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 octets

@"OY4X13X2Y"i._RQ3

Explication:

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

Essayez-le ici.

Ou toute la suite de tests

Python 2, 75 octets

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

Assez simple.

Mathematica 81 octets

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}

Rétine , 52

Il s'agit d'une méthode simple basée sur la substitution:

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

Essayez-le en ligne . Le supplément m`au début de certaines lignes n'est nécessaire que pour tester plusieurs entrées en une seule fois, donc ne sont pas comptés dans le score.

Auparavant, j'ai essayé cette approche plus intéressante , mais c'est un peu plus long (environ 65 sans les mmodificateurs):

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

• remplacer tous les nombres non nuls par 1, laissant des -signes en place
• Remplacer -1par2
• Convertir les 1er et 2e nombres unaires avec 3et1 respectivement comme chiffres unaires. Cela donne effectivement 2 chiffres de base3, exprimés en unaire
• Convertissez en 3s en 111. Cela donne effectivement un seul nombre unaire qui correspond à chacun des quadrants, axes et origine
• Convertir l'unaire en un chiffre décimal
• Transposez le chiffre décimal au caractère de sortie approprié.

Octave, 34 octets

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

L'ancienne astuce base-3 à travers la multiplication des vecteurs (bien que je devais ajouter 5 pour tenir compte des indices de tableau basés sur 1) plus une certaine magie d'indexation d'octave.

L'entrée est un vecteur de la forme [1, -2](avec ou sans virgule), donc lorsqu'elle est affectée à une variablew :

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

Ici, c'est sur ideone .

Pyth, 24

Trop longue, mais peut-être une approche intéressante:

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

L'entrée doit être spécifiée comme un nombre complexe, par exemple 1-2j. Fondamentalement, un ternaire imbriqué pour tester:

• si l'entrée est nulle - sortie O
• sinon si la partie réelle est nulle - sortie Y
• sinon si la partie imaginaire est nulle - sortie X
• Sinon, calculez la phase complexe, multipliez par 2, divisez l'entier par π, puis modifiez et ajoutez pour donner le nombre de quadrants approprié.

Essayez-le en ligne.

Java 8, 64 octets

c'est une expression lambda pour 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 octets pourraient être économisés en renvoyant un Characterau lieu d'un, Stringmais je ne suis pas complètement sûr que l'autoboxing fonctionnera bien avec le lambda.