编写一个程序或函数，该程序或函数接受两个整数，这些整数表示笛卡尔平面上某点的X和Y坐标。

该输入可以进来任何合理的格式，只要该X值Y.例如之前到来时，1 -2，(1,-2)，[1, -2]，或1\n-2都将是罚款X = 1，Y = -2。

打印或返回描述该点在平面中位置的单个字符串（后跟可选的尾随换行符）：

• 1如果点在象限 I
• 2 如果该点在第二象限中
• 3 如果该点在象限III中
• 4 如果该点在象限IV中
• X如果该点在x轴上（x不允许小写）
• Y如果点在y轴上（y不允许小写）
• O 如果该点在原点上（那是一个大写字母“哦”，而不是零）

以字节为单位的最短代码获胜。决胜局将进入投票较高的答案。

测试用例

(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

果冻，14个字节

Ṡḅ3ị“Y4X13X2YO

在线尝试！

怎么运行的

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

Ruby，35个字节

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

利用“太空飞船”（<=>）运算符。

x <=> 0 将返回

• 0 如果 x == 0
• 1 如果 x > 0
• -1 如果 x < 0

因此，

• 如果x == 0，我们返回'OY'[y<=>0]。这是

  • O如果y == 0（在的字符串索引0）

  • Yif y != 0（这是正确的，因为两者都存在，1并且在对该字符串进行索引时-1将导致Yas -1指向字符串中的最后一个字符，该字符也恰好是索引1处的那个）

• 如果x > 0，我们返回'X14'[y<=>0]。这是Xif y == 0，1if y > 0和4if y < 0（请参见上面的说明）。

• 如果x < 0，我们返回'X23'[y<=>0]。

JavaScript，44个字节

(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个字节

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

比所有这些三元组短一个整字节！

Japt，30 22字节

"3Y2XOX4Y1"g4+3*Ug +Vg

受到@Dennis的果冻答案的启发，然后他添加了解释。在线测试！

有趣的事实：如果我在g字符串函数中添加了对负数的支持，则这将缩短两个字节。

另一种尝试，更接近果冻（23字节）：

"3Y2XOX4Y1"gNmg m+1 ¬n3

可悲的是，增加列表成本为4个字节...

MATL，22字节

'3X2YOY4X1'iZSQI1h*sQ)

这使用该语言/编译器的当前版本（10.2.1）。

在线尝试！

说明

这无耻地借用了丹尼斯回答中的伟大方法。

'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个字节

@"OY4X13X2Y"i._RQ3

说明：

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

在这里尝试。

或整个测试套件

Python 2，75个字节

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

非常简单。

Mathematica 81字节

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}

视网膜 52岁

这是一个简单的基于替换的方法：

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

在线尝试。m`某些行开头的多余内容仅需要一次性测试多个输入，因此不会计入分数。

以前，我尝试过这种更有趣的方法，但是它的时间要长得多（不带m修饰符的情况下约为65 ）：

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

• 将所有非零数字替换为1，将-符号保留在适当的位置
• 替换-1为2
• 将第一个和第二个数字一元分别用3和转换1为一位数。这有效地给出了以2进制表示的2个base3数字
• 将转换3为111。这有效地给出了一个对应于每个象限，轴和原点的单一一元数
• 将一元转换为一个十进制数字
• 将十进制数字转置为适当的输出字符。

八度，34字节

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

向量乘法的旧的base-3技巧（尽管我不得不加5来考虑基于1的数组索引）以及一些Octave索引魔术。

输入是形式为向量[1, -2]（带或不带逗号）的向量，因此当分配给变量时w：

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

这是在ideone上。

Pyth，24岁

时间过长，但也许是一种有趣的方法：

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

输入必须指定为复数，例如1-2j。基本上是要测试的嵌套三元：

• 如果输入为零-输出 O
• 否则，如果实部为零-输出 Y
• 否则，如果虚部为零，则输出 X
• 否则计算复数相位，乘以2，将整数除以π，然后进行mod加法得到适当的象限数。

在线尝试。

Java 8，64字节

这是的lambda表达式BiFunction<Integer,Integer,String>。

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

通过返回a Character而不是a 可以节省3个字节，String但是我不能完全确定autoboxing是否可以很好地与lambda配合使用。