Viết chương trình hoặc hàm lấy hai số nguyên biểu thị tọa độ X và Y của một điểm trên mặt phẳng Cartesian .

Các đầu vào có thể đến ở bất kỳ định dạng hợp lý miễn là giá trị X đứng trước Y. Ví dụ 1 -2, (1,-2), [1, -2], hoặc 1\n-2tất cả sẽ tốt cho X = 1, Y = -2.

In hoặc trả về một chuỗi ký tự đơn (theo sau là một dòng mới tùy chọn) mô tả vị trí của điểm trong mặt phẳng:

• 1nếu điểm nằm trong góc phần tư tôi
• 2 nếu điểm nằm trong góc phần tư II
• 3 nếu điểm nằm trong góc phần tư III
• 4 nếu điểm nằm trong góc phần tư IV
• Xnếu điểm nằm trên trục x (chữ thường xkhông được phép)
• Ynếu điểm nằm trên trục y (chữ thường ykhông được phép)
• O nếu điểm nằm trên điểm gốc (đó là chữ in hoa "oh", không phải số không)

Mã ngắn nhất tính bằng byte thắng. Tiebreaker đi đến câu trả lời bình chọn cao hơn.

Các trường hợp thử nghiệm

(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

Thạch, 14 byte

Ṡḅ3ị“Y4X13X2YO

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

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

Tận dụng toán tử "tàu vũ trụ" ( <=>).

x <=> 0 sẽ trở lại

• 0 nếu x == 0
• 1 nếu x > 0
• -1 nếu x < 0

Vì thế,

• nếu x == 0, chúng tôi trở lại 'OY'[y<=>0]. Đây là

  • Oif y == 0(lập chỉ mục chuỗi tại 0)

  • Yif y != 0(điều này đúng vì cả hai 1và -1sẽ dẫn đến Ykhi lập chỉ mục trên chuỗi này, như -1đề cập đến ký tự cuối cùng trong chuỗi, cũng xảy ra là một trong chỉ mục 1)

• nếu x > 0, chúng tôi trở lại 'X14'[y<=>0]. Đây là Xnếu y == 0, 1nếu y > 0và 4nếu y < 0(xem giải thích ở trên).

• nếu x < 0, chúng tôi trở lại '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)]

Toàn bộ byte ngắn hơn tất cả những con chim nhạn đó!

Japt, 30 22 byte

"3Y2XOX4Y1"g4+3*Ug +Vg

Lấy cảm hứng từ câu trả lời của @Dennis 'Jelly trước khi anh ấy thêm một lời giải thích. Kiểm tra nó trực tuyến!

Thực tế thú vị: đây sẽ là hai byte ngắn hơn nếu tôi đã thêm hỗ trợ cho các số âm trong ghàm cho chuỗi.

Một nỗ lực khác, gần hơn với Jelly one (23 byte):

"3Y2XOX4Y1"gNmg m+1 ¬n3

Đáng buồn thay, việc tăng một danh sách tốn 4 byte ...

MATL , 22 byte

'3X2YOY4X1'iZSQI1h*sQ)

Điều này sử dụng bản phát hành hiện tại (10.2.1) của ngôn ngữ / trình biên dịch.

Hãy thử trực tuyến!

Giải trình

Điều này đáng xấu hổ mượn cách tiếp cận tuyệt vời trong câu trả lời của 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

Bình thường, 18 byte

@"OY4X13X2Y"i._RQ3

Giải trình:

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

Hãy thử nó ở đây.

Hoặc toàn bộ bộ kiểm tra

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)]

Khá đơn giản.

Toán học 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}

Võng mạc , 52

Đây là một phương pháp dựa trên thay thế đơn giản:

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

Hãy thử trực tuyến . Phần bổ sung m`khi bắt đầu một số dòng chỉ cần thiết để kiểm tra nhiều đầu vào trong một lần, do đó không được tính vào điểm số.

Trước đây tôi đã thử cách tiếp cận thú vị hơn này , nhưng nó dài hơn một chút (khoảng 65 mà không cần msửa đổi):

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

• thay thế tất cả các số khác không 1, để lại -các dấu hiệu
• Thay thế -1bằng2
• Chuyển đổi số 1 và số 2 unary với 3và 1tương ứng là các chữ số đơn. Điều này có hiệu quả cho 2 chữ số cơ bản, được biểu thị bằng unary
• Chuyển đổi sang 3s thành 111. Điều này thực sự mang lại một số đơn nhất tương ứng với mỗi góc phần tư, trục và gốc
• Chuyển đổi unary thành một chữ số thập phân
• Chuyển chữ số thập phân sang char đầu ra thích hợp.

Octave, 34 byte

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

Thủ thuật cơ sở 3 cũ thông qua phép nhân vectơ (mặc dù tôi đã phải thêm 5 vào tài khoản cho các chỉ số mảng dựa trên 1) cộng với một số phép thuật lập chỉ mục Octave.

Đầu vào là một vectơ có dạng [1, -2](có hoặc không có dấu phẩy), vì vậy khi được gán cho một biến w:

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

Đây là trên ideone .

Bình thường, 24

Quá dài, nhưng có lẽ là một cách tiếp cận thú vị:

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

Đầu vào phải được chỉ định là một số phức, ví dụ 1-2j. Về cơ bản là một ternary lồng nhau để kiểm tra:

• nếu đầu vào bằng không - đầu ra O
• khác nếu phần thực bằng không - đầu ra Y
• khác nếu phần ảo là zero - đầu ra X
• khác tính pha phức, nhân với 2, số nguyên chia cho π, sau đó mod và thêm để cho số góc phần tư thích hợp.

Hãy thử trực tuyến.

Java 8, 64 byte

đây là một biểu thức lambda cho 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 có thể được lưu bằng cách trả về một Characterthay vì một Stringnhưng tôi không hoàn toàn chắc chắn nếu hộp thư tự động sẽ chơi tốt với lambda.