Schreiben Sie ein Programm oder eine Funktion mit zwei Ganzzahlen, die die X- und Y-Koordinaten eines Punktes auf einer kartesischen Ebene darstellen .

Die Eingabe in jedem angemessenen Format kommen kann , solange der Wert X kommt vor der Y. Zum Beispiel 1 -2, (1,-2), [1, -2], oder 1\n-2alle in Ordnung sein würde , für X = 1, Y = -2.

Drucken Sie eine einzelne Zeichenfolge (gefolgt von einer optionalen nachgestellten Zeile), die die Position des Punkts in der Ebene beschreibt, oder geben Sie sie zurück:

• 1wenn der Punkt in Quadrant I liegt
• 2 wenn der Punkt in Quadrant II liegt
• 3 wenn der Punkt in Quadrant III liegt
• 4 wenn der Punkt in Quadrant IV liegt
• Xwenn der Punkt auf der x-Achse liegt (Kleinbuchstaben xsind nicht erlaubt)
• Ywenn der Punkt auf der y-Achse liegt (Kleinbuchstaben ysind nicht erlaubt)
• O wenn der Punkt auf dem Ursprung liegt (das ist ein Großbuchstabe "oh", nicht Null)

Der kürzeste Code in Bytes gewinnt. Tiebreaker geht zur höher bewerteten Antwort.

Testfälle

(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

Jelly, 14 Bytes

Ṡḅ3ị“Y4X13X2YO

Probieren Sie es online!

Wie es funktioniert

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

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

Nutzung des <=>Operators "Raumschiff" ( ).

x <=> 0 wird zurückkehren

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

Daher,

• Wenn x == 0ja, kehren wir zurück 'OY'[y<=>0]. Das ist

  • Oif y == 0(String-Indizierung bei 0)

  • Ywenn y != 0(dies , weil beide wahr ist , 1und -1in Folge wird , Ywenn die Indizierung auf dieser Zeichenfolge als -1bezieht sich auf das letzte Zeichen in der Zeichenfolge, die auch derjenige bei Index 1 passiert werden)

• Wenn x > 0ja, kehren wir zurück 'X14'[y<=>0]. Dies ist Xif y == 0, 1if y > 0und 4if y < 0(siehe obige Erklärung).

• Wenn x < 0ja, kehren wir zurück 'X23'[y<=>0].

JavaScript, 44 Bytes

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

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

Ein ganzes Byte kürzer als all diese Ternaries!

Japt, 30 22 Bytes

"3Y2XOX4Y1"g4+3*Ug +Vg

Inspiriert von der Antwort von @Dennis 'Jelly, bevor er eine Erklärung hinzufügte. Online testen!

Unterhaltsame Tatsache: Dies wäre zwei Bytes kürzer, wenn ich in der gFunktion für Zeichenfolgen die Unterstützung für negative Zahlen hinzugefügt hätte .

Ein weiterer Versuch, näher am Jelly One (23 Bytes):

"3Y2XOX4Y1"gNmg m+1 ¬n3

Leider kostet das Inkrementieren einer Liste 4 Bytes ...

MATL , 22 Bytes

'3X2YOY4X1'iZSQI1h*sQ)

Dies verwendet die aktuelle Version (10.2.1) der Sprache / des Compilers.

Probieren Sie es online!

Erläuterung

Dies leiht schamlos den großartigen Ansatz in Dennis 'Antwort .

'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 Bytes

@"OY4X13X2Y"i._RQ3

Erläuterung:

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

Probieren Sie es hier aus.

Oder die ganze Testsuite

Python 2, 75 Bytes

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

Ziemlich einfach.

Mathematica 81 Bytes

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}

Netzhaut , 52

Dies ist eine einfache, auf Substitution basierende Methode:

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

Probieren Sie es online aus . Das Extra m`am Anfang einiger Zeilen wird nur benötigt, um mehrere Eingaben auf einmal zu testen, und wird daher nicht in der Punktzahl berücksichtigt.

Früher habe ich diesen interessanteren Ansatz ausprobiert , aber er ist ziemlich viel länger (ungefähr 65 ohne die mModifikatoren):

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

• Ersetzen Sie alle Zahlen ungleich Null durch 1und lassen Sie die -Zeichen an Ort und Stelle
• Ersetze -1mit2
• Konvertieren Sie die erste und die zweite Zahl mit 3und 1als unäre Ziffern. Dies ergibt effektiv 2 Base3-Ziffern, ausgedrückt in Unary
• Konvertiere zu 3s zu 111. Dies ergibt effektiv eine einzelne unäre Zahl, die jedem der Quadranten, Achsen und Ursprung entspricht
• Konvertieren Sie die unäre in eine Dezimalstelle
• Transponieren Sie die Dezimalstelle in das entsprechende Ausgabezeichen.

Oktave, 34 Bytes

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

Der alte Basis-3-Trick durch Vektormultiplikation (obwohl ich 5 addieren musste, um 1-basierte Array-Indizes zu berücksichtigen) plus etwas Octave-Indizierungsmagie.

Die Eingabe ist ein Vektor des Formulars [1, -2](mit oder ohne Komma). Wenn also einer Variablen zugewiesen w:

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

Hier ist es auf ideone .

Pyth, 24

Zu lange, aber vielleicht ein interessanter Ansatz:

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

Die Eingabe muss als komplexe Zahl angegeben werden, z 1-2j. Grundsätzlich ein geschachtelter Ternär zum Testen:

• Wenn der Eingang Null ist, wird er ausgegeben O
• sonst, wenn Realteil Null ist - Ausgabe Y
• sonst, wenn Imaginärteil Null ist - Ausgabe X
• Andernfalls berechnen Sie die komplexe Phase, multiplizieren Sie sie mit 2, dividieren Sie sie durch π, modifizieren Sie sie und addieren Sie sie, um die entsprechende Quadrantenzahl zu erhalten.

Probieren Sie es online aus.

Java 8, 64 Bytes

Dies ist ein Lambda-Ausdruck für 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 Bytes könnten durch Rückgabe von a Characteranstelle von a gespeichert werden, Stringaber ich bin nicht ganz sicher, ob Autoboxing gut mit dem Lambda funktioniert.