Aufgabe

Bei einer positiven Ganzzahl nwird ausgegeben, n+1wenn nungerade ist, und ausgegeben, n-1wenn gerade nist.

Eingang

Eine positive ganze Zahl. Sie können davon ausgehen, dass sich die Ganzzahl innerhalb der Verarbeitungskapazität der Sprache befindet.

Ausgabe

Eine positive ganze Zahl, wie oben angegeben.

Testfälle

input output
    1      2
    2      1
    3      4
    4      3
    5      6
    6      5
    7      8
    8      7
  313    314
  314    313

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Es gelten Standardlücken .

Verweise

• OEIS A103889

C 20 Bytes

f(x){return-(-x^1);}

Probieren Sie es online aus .

Stapel Katzen , 3 + 3 ( -n) = 6 Bytes

-*-

Probieren Sie es online!

Braucht die -n Flag, um mit numerischer Eingabe und Ausgabe zu arbeiten.

Erläuterung

Stack Cats ist in der Regel weit davon entfernt, wettbewerbsfähig zu sein, da es sich bei den Befehlen um Injektionen und bei den meisten um Involutionen handelt und jedes Programm eine Spiegelsymmetrie aufweisen muss. Eine der Involutionen besteht jedoch darin, das niedrigstwertige Bit einer Zahl umzuschalten, und wir können den Wert durch eine ebenfalls vorhandene unäre Negation ausgleichen. Zum Glück gibt uns das ein symmetrisches Programm, sodass wir uns um nichts anderes kümmern müssen:

-   Multiply the input by -1.
*   Toggle the least significant bit of the value (i.e. take it XOR 1).
-   Multiply the result by -1.

Eingabe und Ausgabe sind am Anfang und Ende des Programms implizit, da die Eingabe und Ausgabe nicht umkehrbar ist und daher keine Befehle sein können.

x86-Assembly, 9 Byte (für konkurrierende Einträge)

Jedem, der diese Herausforderung in Hochsprachen versucht, entgeht der wahre Spaß, rohe Teile zu manipulieren. Es gibt so viele subtile Variationen, es ist verrückt - und es macht viel Spaß, darüber nachzudenken. Hier sind einige Lösungen, die ich in der 32-Bit-x86-Assemblersprache entwickelt habe.

Ich entschuldige mich im Voraus, dass dies nicht die typische Code-Golf-Antwort ist. Ich werde viel über den Gedankenprozess der iterativen Optimierung (für die Größe) streifen. Hoffentlich ist das interessant und lehrreich für ein größeres Publikum, aber wenn Sie der TL; DR-Typ sind, werde ich nicht beleidigt sein, wenn Sie bis zum Ende springen.

Die naheliegende und effiziente Lösung besteht darin, zu testen, ob der Wert ungerade oder gerade ist (was effizient durch Betrachten des niedrigstwertigen Bits erfolgen kann), und dann entsprechend zwischen n + 1 oder n - 1 zu wählen . Unter der Annahme, dass die Eingabe als Parameter im ECXRegister übergeben wird und das Ergebnis im EAXRegister zurückgegeben wird, erhalten wir die folgende Funktion:

F6 C1 01  |  test  cl, 1                      ; test last bit to see if odd or even
8D 41 01  |  lea   eax, DWORD PTR [ecx + 1]   ; set EAX to n+1 (without clobbering flags)
8D 49 FF  |  lea   ecx, DWORD PTR [ecx - 1]   ; set ECX to n-1 (without clobbering flags)
0F 44 C1  |  cmovz eax, ecx                   ; move in different result if input was even
C3        |  ret

^{(13 Bytes)}

Für Code-Golf-Zwecke sind diese LEAAnweisungen jedoch nicht besonders gut, da sie 3 Byte zum Codieren benötigen. Eine einfache DECRementation von ECXwäre viel kürzer (nur ein Byte), dies wirkt sich jedoch auf Flags aus. Wir müssen also etwas geschickter sein, wie wir den Code anordnen. Wir können die Abnahme tun zuerst , und die gerade / ungerade Test zweite , aber dann haben wir das Ergebnis der gerade / ungerade Test invertieren.

Außerdem können wir die Anweisung zum bedingten Verschieben in eine Verzweigung ändern, wodurch der Code möglicherweise langsamer ausgeführt wird (je nachdem, wie vorhersehbar die Verzweigung ist) Muster, es wird schneller sein), was uns ein weiteres Byte sparen wird.

Tatsächlich kann mit dieser Überarbeitung die gesamte Operation an Ort und Stelle ausgeführt werden, wobei nur ein einziges Register verwendet wird. Das ist großartig, wenn Sie diesen Code irgendwo einfügen (und es ist wahrscheinlich, dass er so kurz ist).

    48     |  dec  eax          ; decrement first
    A8 01  |  test al, 1        ; test last bit to see if odd or even
    75 02  |  jnz  InputWasEven ; (decrement means test result is inverted)
    40     |  inc  eax          ; undo the decrement...
    40     |  inc  eax          ; ...and add 1
  InputWasEven:                 ; (two 1-byte INCs are shorter than one 3-byte ADD with 2)

^{(Inline: 7 Bytes; als Funktion: 10 Bytes)}

Aber was, wenn Sie es zu einer Funktion machen wollten? Keine Standardaufrufkonvention verwendet für die Übergabe von Parametern dasselbe Register wie für den Rückgabewert. Daher müssen Sie MOVam Anfang oder Ende der Funktion eine Register-Register- Anweisung hinzufügen . Dies hat praktisch keine Kosten für die Geschwindigkeit, fügt jedoch 2 Bytes hinzu. (Die RETAnweisung fügt auch ein Byte hinzu, und es entsteht ein gewisser Overhead durch die Notwendigkeit, einen Funktionsaufruf auszuführen und von diesem zurückzukehren. Dies ist also ein Beispiel, bei dem Inlining sowohl einen Geschwindigkeits- als auch einen Größenvorteil erzeugt, anstatt nur eine klassische Geschwindigkeit zu sein -für-den-Raum-Kompromiss.) Insgesamt wird dieser Code als Funktion auf 10 Bytes aufgebläht.

Was können wir in 10 Bytes noch tun? Wenn es uns überhaupt um Leistung geht (zumindest vorhersehbare Leistung), wäre es schön, diesen Zweig loszuwerden. Hier ist eine verzweigungslose Bit-Twiddling-Lösung mit der gleichen Größe in Bytes. Die Grundvoraussetzung ist einfach: Wir verwenden ein bitweises XOR, um das letzte Bit umzukehren und einen ungeraden Wert in einen geraden Wert umzuwandeln und umgekehrt. Aber es gibt ein Problem - für ungerade Eingaben erhalten wir n-1 , für gerade Eingaben erhalten wir n + 1 - genau das Gegenteil von dem, was wir wollen. Um dies zu beheben, führen wir die Operation mit einem negativen Wert durch, wobei das Vorzeichen effektiv umgedreht wird.

8B C1     |  mov eax, ecx   ; copy parameter (ECX) to return register (EAX)
          |
F7 D8     |  neg eax        ; two's-complement negation
83 F0 01  |  xor eax, 1     ; XOR last bit to invert odd/even
F7 D8     |  neg eax        ; two's-complement negation
          |
C3        |  ret            ; return from function

^{(Inline: 7 Bytes; als Funktion: 10 Bytes)}

Ziemlich glatt; Es ist schwer zu erkennen, wie das verbessert werden kann. Eines fällt mir jedoch auf: diese zwei 2-Byte- NEGAnweisungen. Ehrlich gesagt scheinen zwei Bytes ein Byte zu viel zu sein, um eine einfache Negation zu codieren, aber das ist der Befehlssatz, mit dem wir arbeiten müssen. Gibt es Workarounds? Sicher! Wenn wir XORdurch -2 ersetzen, können wir die zweite NEGAtion durch eine INCZement ersetzen:

8B C1     |  mov eax, ecx
          |
F7 D8     |  neg eax
83 F0 FE  |  xor eax, -2
40        |  inc eax
          |
C3        |  ret

^{(Inline: 6 Bytes; als Funktion: 9 Bytes)}

Ein weiterer die Merkwürdigkeiten des x86 - Befehlssatzes ist die Mehrzweck LEAAnweisung , die ein Register-Register bewegen tun, ein Register-Register zusätzlich durch eine konstanten Ausgleich, und das alles in einem einzigen Befehl Skalierung!

8B C1        |  mov eax, ecx
83 E0 01     |  and eax, 1        ; set EAX to 1 if even, or 0 if odd
8D 44 41 FF  |  lea eax, DWORD PTR [ecx + eax*2 - 1]
C3           |  ret

^{(10 Bytes)}

Der ANDBefehl entspricht dem TESTzuvor verwendeten Befehl, da beide ein bitweises UND ausführen und die Flags entsprechend setzen, aber ANDden Zieloperanden tatsächlich aktualisieren. Der LEABefehl skaliert dies dann um 2, addiert den ursprünglichen Eingabewert und dekrementiert ihn um 1. Wenn der Eingabewert ungerade war, subtrahiert dies 1 (2 × 0 - 1 = –1) davon; Wenn der Eingabewert gerade war, wird 1 (2 × 1 - 1 = 1) hinzugefügt.

Dies ist eine sehr schnelle und effiziente Methode, um den Code zu schreiben, da ein Großteil der Ausführung im Front-End ausgeführt werden kann, aber es bringt uns nicht viel mit Bytes, da so viele zum Codieren eines Komplexes erforderlich sind LEAAnweisung. Diese Version funktioniert auch nicht so gut für Inlining-Zwecke, da der ursprüngliche Eingabewert als Eingabe der LEAAnweisung beibehalten werden muss . Mit diesem letzten Optimierungsversuch sind wir also tatsächlich zurückgegangen, was darauf hindeutet, dass es an der Zeit ist, damit aufzuhören.

Für den letzten konkurrierenden Eintrag haben wir also eine 9-Byte-Funktion, die den Eingabewert in das ECXRegister (eine registerbasierte Semistandard-Aufrufkonvention für 32-Bit x86) aufnimmt und das Ergebnis im EAXRegister zurückgibt (wie bei alle x86-Aufrufkonventionen):

           SwapParity PROC
8B C1         mov eax, ecx
F7 D8         neg eax
83 F0 FE      xor eax, -2
40            inc eax
C3            ret
           SwapParity ENDP

Montagefertig mit MASM; Aufruf von C als:

extern int __fastcall SwapParity(int value);                 // MSVC
extern int __attribute__((fastcall)) SwapParity(int value);  // GNU   

Gelee , 3 Bytes

-*ạ

Probieren Sie es online!

Pseudocode: abs((-1)**n - n)

Python3, 20 bis 18 Bytes

lambda n:n-1+n%2*2

Ziemlich einfach. Zuerst berechnen wir n-1 und entscheiden, ob wir 2 hinzufügen wollen oder nicht.

Wenn n gerade ist -> n mod 2 wird 0 sein, so werden wir 2 * 0 zu n-1 addieren , was zu n-1 führt .

Wenn n ungerade ist -> n mod 2 ist 1, so addieren wir 2 * 1 zu n-1 , was zu n + 1 führt .

Ich bevorzuge eine Erklärung, die ich mit MS Paint und einem Laptop-Touchpad gemacht habe ...

Python, 16 Bytes

lambda x:-(-x^1)

Probieren Sie es online!

MATL , 7 Bytes

Q:HePG)

Dadurch werden Rechenoperationen vermieden. Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe 4als Beispiel.

Q    % Implicit input. Add 1
     % STACK: 5
:    % Range
     % STACK: [1 2 3 4 5]
He   % Reshape with 2 rows in column-major order. Pads with a zero if needed
     % STACK: [1 3 5;
               2 4 0]
P    % Flip vertically
     % STACK: [2 4 0;
               1 3 5]
G    % Push input again
     % STACK: [2 4 0;
               1 3 5], 4
)    % Index, 1-based, in column major order. Implicitly display
     % STACK: 3

Braingolf v0.1 , 11 10 Bytes

.1>2,%?+:-

Probieren Sie es online! (Zweites Argument ist der Braingolf-Code, drittes Argument ist die Eingabe)

Ein Byte dank Neil gespeichert

Die erste konkurrierende Braingolf-Antwort: D

Erläuterung:

.            Duplicate the top of the stack
 1>          Push 1 to the bottom of the stack
   2         Push 2 to stack
    ,%       Pop last 2 items, mod them and push result
      ?      If last item > 0
       +     Add the 1 to the input
        :    Else
         -   Subtract the 1 from the input

             No semicolon in code so print last item

Braingolf v0.2 , 9 bytes [nicht konkurrierend]

.2%?1+:1-

Probieren Sie es online! (Zweites Argument ist der Braingolf-Code, drittes Argument ist die Eingabe)

Erklärung siehe oben. Der einzige Unterschied ist, dass in Braingolf v0.2 das Standardverhalten von diadischen Operatoren und die Funktion des ,Modifikators umgekehrt sind, was bedeutet, dass die 2 Kommas in der v0.1-Antwort nicht mehr benötigt werden.

Jedoch wurde v0.2 nach der Herausforderung veröffentlicht, so dass dieser nicht konkurrierend ist

Cubix , 10 9 Bytes

cO1)I(//@

Probieren Sie es online aus

Erläuterung

Netzversion

    c O
    1 )
I ( / / @ . . .
. . . . . . . .
    . .
    . .

Die ausgeführten Zeichen sind

I(1c)O@
I          Input
 (         Decrement
  1c       XOR with 1
    )      Increment
     O@    Output and exit

Python, 68 Bytes

lambda x:[m.floor(x-m.cos(m.pi*x)) for m in [__import__('math')]][0]

Im Geiste eines einzigartigen Ansatzes. Das folgende Diagramm zeigt die Funktion (mit violetten Punkten, die die ersten 10 Fälle darstellen). Es sollte theoretisch möglich sein, eine Lösung für diese Frage auf der Grundlage der meisten (alle?) Periodischen Funktionen (z. B. sin, tan, sec) zu konstruieren. Tatsächlich sollte das Ersetzen von cos für sec im Code funktionieren.

PHP, 15 Bytes

<?=-(-$argn^1);

Javascript, 17 12 Bytes

x=>x-(-1)**x

f=x=>x-(-1)**x;

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

Ein weiterer Ansatz, 10 Bytes _{aus der C-Antwort gestohlen (sssshhh)}

x=>-(-x^1)

f=x=>-(-x^1)

<input id=i oninput=o.innerText=f(this.value) type=number><pre id=o>

JavaScript (ES6), 14 13 12 10 Byte

n=>-(-n^1)

• 1 Byte gespart dank Luke .
• Durch Portierung der C-Lösung von feersum werden 2 Byte eingespart . (Wenn das verpönt ist, lassen Sie es mich bitte wissen und ich werde zu meiner vorherigen Lösung zurückkehren)

Versuch es

f=
n=>-(-n^1)
i.addEventListener("input",_=>o.innerText=f(+i.value))

<input id=i type=number><pre id=o>

Original, 12 Bytes

n=>n-1+n%2*2

Python, 20 Bytes

lambda n:n+(n%2or-1)

n%2or-1 wird 1 zurückgeben, wenn es ungerade ist, aber wenn es gerade ist, n%2 ist es "falsch" (0), also gibt es stattdessen -1 zurück. Dann fügen wir das einfach hinzu n.

Vorherige Lösung, 23 Bytes

lambda n:[n-1,n+1][n%2]

n%2berechnet den Rest, wenn er ndurch 2 geteilt wird. Wenn er gerade ist, wird 0 zurückgegeben, und Element 0 in dieser Liste ist n-1. Wenn es ungerade ist, gibt dies 1 zurück und Element 1 in dieser Liste ist n+1.

Netzhaut , 21 Bytes

.+
$*
^11(?=(11)*$)

Probieren Sie es online! Meine erste Retina-Antwort mit zwei nachgestellten Zeilenumbrüchen! Erläuterung: Die ersten beiden Zeilen werden von dezimal in unär umgewandelt. Die dritte und vierte Zeile subtrahieren zwei von geraden Zahlen. Die letzte Zeile wird zurück in Dezimal umgewandelt, fügt aber auch eine hinzu.

05AB1E , 4 Bytes

(1^(

Probieren Sie es online!

Cubix , 11 Bytes

u%2!I(/+@O<

Probieren Sie es online!

Erläuterung

Netzversion:

    u %
    2 !
I ( / + @ O < .
. . . . . . . .
    . .
    . .

Zeichen werden in der folgenden Reihenfolge ausgeführt:

I(2%!+O@
I        # Take a number as input
 (       # Decrement it
  2%     # Take the parity of the decremented number
         # (0 if the input is odd, 1 if it's even)
    !    # If that number is zero:
     +   #   Add 2
      O  # Output the number
       @ # Terminate the program

Brain-Flak , 36 Bytes

(({})(())){({}[()]<([{}])>)}{}({}{})

Probieren Sie es online!

Ich persönlich bin mit dieser Antwort sehr zufrieden, da sie viel kürzer ist als die herkömmliche Methode zur Lösung dieses Problems.

Erläuterung

Das erste Stück Code

(({})(()))

konvertiert den Stack von nur nnach

n + 1
  1
  n

Dann, während der obere Teil des Stapels nicht Null ist, dekrementieren wir ihn und drehen das Vorzeichen der Zahl darunter

{({}[()]<([{}])>)}

Dann entfernen wir die Null und addieren die beiden verbleibenden Zahlen

{}({}{})

Mathematica, 22 19 Bytes

3 Bytes gespart dank Greg Martin!

#-1[-1][[#~Mod~2]]&

Vorherige Antwort 22 Bytes

#+{-1,1}[[#~Mod~2+1]]&

Erklärung (für vorherige Antwort)

Mathematica hat die nette Funktion, dass Operationen wie das Rechnen automatisch über Listen laufen.

In diesem Fall nehmen wir, Mod[#,2]was 0 oder 1 zurückgibt, aber wir müssen 1 hinzufügen, weil Mathematica-Listen 1-indiziert sind. Wenn es gerade ist , ergibt dies 1 und #-1wird zurückgegeben. Wenn es ungerade ist , ergibt dies 2 und #+1wird zurückgegeben.

Wise , 8 Bytes

-::^~-^-

Probieren Sie es online!

Erläuterung

Wenn dies umgekehrt wäre (Verringern wenn ungerade, Erhöhen wenn gerade), wäre es ziemlich einfach, dies zu tun.

Wir würden nur das letzte Stück drehen.

::^~-^

Das Problem ist, dass wir das letzte bisschen drehen, während wir negativ sind. Die negativen Zahlen weichen von der Negation der Zahlen um 1 ab, ~sodass ein Versatz entsteht, der das Problem löst.

Also nehmen wir einfach das Programm heraus und packen es ein -.

-::^~-^-

Java 8, 16 10 Bytes

n->-(-n^1)

Java 7, 34 28 Bytes

int c(int n){return-(-n^1);}

Langweilige Häfen von @feersums erstaunlicher C-Antwort .
Probieren Sie es hier aus.

Alte Antworten:

Java 8, 16 Bytes

n->n%2<1?n-1:n+1

Java 7, 34 Bytes

int c(int n){return--n%2>0?n:n+2;}

Erklärung (der alten Java 7 Antwort):

Probieren Sie es hier aus.

Die Antwort oben ist eine kürzere Variante, int c(int n){return n%2<1?n-1:n+1;}indem Sie den Raum loswerden.

int c(int n){     // Method with integer parameter and integer return-type
  return--n%2>0?  //  If n-1 mod-2 is 1:
    n             //   Return n-1
   :              //  Else:
    n+2;          //   Return n+1
}                 // End of method

Japt , 6 Bytes

n ^1 n

Probieren Sie es online!

Python, 20 Bytes

lambda n:n+(n&1)*2-1

Befunge 93 , 18 Bytes

&:2%#v_1+.@
@.-1 <

Ich bin noch nicht fertig mit Golfen (hoffe ich).

Ruby, 12 Bytes

->n{-(-n^1)}

R, 17 Bytes

(n=scan())-(-1)^n

wo n=scan()ist der Wert für diese Stelle.

Casio-Basic, 27 Bytes

piecewise(mod(n,2),1,-1)+n

26 Byte für die Funktion, +1 für die Eingabe nin das Parameterfeld.

C 29 Bytes

a(int b){return b%2?b+1:b-1;}

Gelee , 4 Bytes

‘’Ḃ?

Probieren Sie es online!

Batch, 20 Bytes

@cmd/cset/a"-(1^-%1)

Unabhängig wiederentdeckt @ feersums Algorithmus, ehrlich!