Zadanie

Biorąc dodatnia n, wyjście n+1jeśli njest nieparzysta, a wyjście n-1jeśli njest parzysta.

Wkład

Dodatnia liczba całkowita. Możesz założyć, że liczba całkowita mieści się w zakresie możliwości językowych.

Wydajność

Dodatnia liczba całkowita, określona powyżej.

Przypadki testowe

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

Punktacja

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

Obowiązują standardowe luki .

Referencje

• OEIS A103889

C, 20 bajtów

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

Wypróbuj online .

Stack Cats , 3 + 3 ( -n) = 6 bajtów

-*-

Wypróbuj online!

Potrzebuje -nflagi do pracy z numerycznymi danymi wejściowymi i wyjściowymi.

Wyjaśnienie

Stack Cats zazwyczaj nie jest konkurencyjny, ponieważ ma ograniczony zestaw poleceń (z których wszystkie są zastrzykami, a większość z nich to inwolucje) oraz ponieważ każdy program musi mieć lustrzaną symetrię. Jednak jednym z tych dążeń jest przełączanie najmniej znaczącego bitu liczby i możemy zrównoważyć tę wartość za pomocą jednoznacznej negacji, która również istnieje. Na szczęście daje nam to symetryczny program, więc nie musimy się martwić o nic innego:

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

Dane wejściowe i wyjściowe są niejawne na początku i na końcu programu, ponieważ pobieranie danych wejściowych i generowanie danych wyjściowych nie jest operacją odwracalną, więc nie mogą być poleceniami.

Zestaw x86, 9 bajtów (na konkurencyjny wpis)

Wszyscy, którzy podejmują to wyzwanie w językach wysokiego poziomu, tracą prawdziwą frajdę z manipulowania surowymi bitami. Jest tak wiele subtelnych odmian sposobów na zrobienie tego, jest to szalone - i dużo zabawy o tym myśleć. Oto kilka rozwiązań, które opracowałem w 32-bitowym języku asemblera x86.

Z góry przepraszam, że nie jest to typowa odpowiedź na golfa. Będę dużo gadać na temat procesu iteracyjnej optymalizacji (dla rozmiaru). Mam nadzieję, że jest to interesujące i edukacyjne dla większej grupy odbiorców, ale jeśli jesteś typem TL; DR, nie obrażę się, jeśli przejdziesz do końca.

Oczywistym i wydajnym rozwiązaniem jest sprawdzenie, czy wartość jest nieparzysta, czy parzysta (co można zrobić skutecznie, patrząc na najmniej znaczący bit), a następnie odpowiednio wybrać pomiędzy n + 1 lub n-1 . Zakładając, że dane wejściowe są przekazywane jako parametr w ECXrejestrze, a wynik jest zwracany w EAXrejestrze, otrzymujemy następującą funkcję:

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 bajtów)}

Ale do celów gry w golfa LEAinstrukcje te nie są świetne, ponieważ kodowanie zajmuje 3 bajty. Prosta DECwersja ECXbyłaby znacznie krótsza (tylko jeden bajt), ale wpływa to na flagi, więc musimy być nieco sprytni w sposobie rozmieszczania kodu. Możemy wykonać ubytek pierwszy i parzyste / nieparzyste Test sekund , ale potem musimy odwrócić wynik testu parzyste / nieparzyste.

Możemy również zmienić instrukcję warunkowego przeniesienia na gałąź, co może spowodować, że kod będzie działał wolniej (w zależności od przewidywalności gałęzi - jeśli dane wejściowe zmieniają się niekonsekwentnie między nieparzystymi i parzystymi, gałąź będzie wolniejsza; jeśli istnieje wzór, będzie szybciej), co pozwoli nam zaoszczędzić kolejny bajt.

W rzeczywistości dzięki tej zmianie cała operacja może być wykonana w miejscu, przy użyciu tylko jednego rejestru. Jest to świetne, jeśli wstawiasz gdzieś ten kod (i są szanse, że tak, ponieważ jest tak krótki).

    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)

^{(wstawiany: 7 bajtów; jako funkcja: 10 bajtów)}

Ale co, jeśli chcesz, aby była to funkcja? Żadna standardowa konwencja wywoływania nie używa tego samego rejestru do przekazywania parametrów, jak ma to miejsce w przypadku wartości zwracanej, dlatego konieczne byłoby dodanie MOVinstrukcji rejestru-rejestru na początku lub na końcu funkcji. To nie ma praktycznie żadnego kosztu prędkości, ale dodaje 2 bajty. ( RETInstrukcja dodaje również bajt i istnieje pewien narzut związany z koniecznością wykonania i powrotu z wywołania funkcji, co oznacza, że ​​jest to jeden z przykładów, w którym wstawianie daje korzyści zarówno prędkości, jak i wielkości, a nie tylko klasyczną prędkość - dla kompromisu przestrzeni.) W sumie, napisany jako funkcja, ten kod rośnie do 10 bajtów.

Co jeszcze możemy zrobić w 10 bajtach? Jeśli zależy nam w ogóle na wydajności (przynajmniej przewidywalnej wydajności), dobrze byłoby pozbyć się tej gałęzi. Oto bez rozgałęziające, zmieniające się w bitach rozwiązanie, które ma ten sam rozmiar w bajtach. Podstawowa zasada jest prosta: używamy bitowego XOR, aby odwrócić ostatni bit, konwertując wartość nieparzystą na parzystą i odwrotnie. Ale jest jeden problem - dla nieparzystych danych wejściowych, który daje nam n-1 , podczas gdy dla parzystych danych wejściowych daje nam n + 1 - dokładnie przeciwnie do tego, czego chcemy. Aby to naprawić, wykonujemy operację na wartości ujemnej, skutecznie odwracając znak.

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

^{(wstawiany: 7 bajtów; jako funkcja: 10 bajtów)}

Całkiem zręczny; trudno jest zrozumieć, jak można to poprawić. Jedno rzuca się w oczy: te dwie 2-bajtowe NEGinstrukcje. Szczerze mówiąc, dwa bajty wydają się być o jeden bajt za dużo, by zakodować prostą negację, ale to zestaw instrukcji, z którymi musimy pracować. Czy są jakieś obejścia? Pewnie! Jeśli otrzymamy XOR-2, możemy zamienić drugą NEGację na INCrement:

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

^{(wstawiany: 6 bajtów; jako funkcja: 9 bajtów)}

Inną osobliwością zestawu instrukcji x86 jest instrukcja uniwersalnaLEA , która może wykonać ruch rejestru-rejestru, dodanie rejestru-rejestru, przesunięcie przez stałą i skalowanie wszystkiego w jednej instrukcji!

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 bajtów)}

ANDInstrukcja jest podobna do TESTinstrukcji używaliśmy wcześniej, że zarówno zrobić bitowe AND i ustawić odpowiednio flagi, ale ANDfaktycznie uaktualnia operand przeznaczenia. Następnie LEAinstrukcja skaluje to o 2, dodaje oryginalną wartość wejściową i zmniejsza o 1. Jeśli wartość wejściowa była nieparzysta, odejmuje to 1 (2 × 0 - 1 = -1); jeśli wartość wejściowa była parzysta, to dodaje 1 (2 × 1 - 1 = 1).

Jest to bardzo szybki i skuteczny sposób na napisanie kodu, ponieważ znaczną część wykonania można wykonać w interfejsie, ale nie kupuje nam to zbyt wiele bajtów, ponieważ tak wiele zajmuje kodowanie złożonego LEAinstrukcja. Ta wersja również nie działa tak dobrze dla celów wstawiania, ponieważ wymaga zachowania oryginalnej wartości wejściowej jako danych wejściowych LEAinstrukcji. Tak więc przy ostatniej próbie optymalizacji cofnęliśmy się, sugerując, że nadszedł czas, aby się zatrzymać.

Tak więc, dla końcowego konkurencyjnego wpisu, mamy 9-bajtową funkcję, która pobiera wartość wejściową do ECXrejestru (pół-standardowa konwencja wywoływania oparta na rejestrze na 32-bitowym x86) i zwraca wynik w EAXrejestrze (jak w przypadku wszystkie konwencje wywoływania x86):

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

Gotowy do montażu za pomocą MASM; zadzwoń z C jako:

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

Galaretka , 3 bajty

-*ạ

Wypróbuj online!

Pseudo kod: abs((-1)**n - n)

Python3, 20 18 bajtów

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

Dość proste. Najpierw obliczamy n-1 i decydujemy, czy dodać do niego 2, czy nie.

Jeśli n jest parzyste -> n mod 2 będzie wynosić 0, dlatego dodamy 2 * 0 do n-1 , co daje n-1 .

Jeśli n jest nieparzyste -> n mod 2 będzie wynosić 1, dlatego dodamy 2 * 1 do n-1 , w wyniku czego n + 1 .

Wolę wyjaśnienie, które zrobiłem za pomocą MS paint i touchpada do laptopa ...

Python, 16 bajtów

lambda x:-(-x^1)

Wypróbuj online!

MATL , 7 bajtów

Q:HePG)

Pozwala to uniknąć operacji arytmetycznych. Wypróbuj online!

Wyjaśnienie

Rozważ dane wejściowe 4jako przykład.

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 bajtów

.1>2,%?+:-

Wypróbuj online! (Drugi argument to kod Braingolfa, trzeci argument to dane wejściowe)

Zapisano bajt dzięki Neilowi

Pierwsza w historii konkurencyjna odpowiedź braingolfa: D

Wyjaśnienie:

.            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 bajtów [niekonkurujący]

.2%?1+:1-

Wypróbuj online! (Drugi argument to kod Braingolfa, trzeci argument to dane wejściowe)

Wyjaśnienia znajdują się powyżej. Jedyną różnicą jest Braingolf v0.2, domyślne zachowanie operatorów diadycznych i funkcja ,modyfikatora są odwrócone, co oznacza, że ​​2 przecinki w odpowiedzi v0.1 nie są już potrzebne.

Jednak po wyzwaniu została wydana wersja v0.2, więc ta nie jest konkurencyjna

Cubix , 10 9 bajtów

cO1)I(//@

Wypróbuj online

Wyjaśnienie

Wersja netto

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

Wykonane postacie to

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

Python, 68 bajtów

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

W duchu wyjątkowego podejścia. Poniższy wykres pokazuje funkcję (z fioletowymi kropkami reprezentującymi pierwsze 10 przypadków). Teoretycznie powinno być możliwe skonstruowanie rozwiązania tego pytania na podstawie większości (wszystkich?) Funkcji okresowych (np. Sin, tan, sec). W rzeczywistości podstawianie cos na sec w kodzie, tak jak powinno, powinno działać.

PHP, 15 bajtów

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

JavaScript, 17 12 bajtów

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

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

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

Inne podejście, 10 bajtów _{skradzionych z odpowiedzi C (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 bajtów

n=>-(-n^1)

• 1 bajt zapisany dzięki Łukaszowi .
• 2 bajty zapisane przez przeniesienie rozwiązania C feersum . (Jeśli to się nie podoba, daj mi znać, a cofnę się do mojego poprzedniego rozwiązania poniżej)

Spróbuj

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

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

Oryginalny, 12 bajtów

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

Python, 20 bajtów

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

n%2or-1zwróci 1, jeśli jest nieparzysty, ale jeśli jest parzysty, n%2to „false” (0), więc zamiast tego zwraca -1. Następnie po prostu dodajemy to do n.

Poprzednie rozwiązanie, 23 bajty

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

n%2oblicza resztę po npodzieleniu przez 2. Jeśli jest parzysta, to zwraca 0, a element 0 na tej liście to n-1. Jeśli jest nieparzysty, zwraca 1, a element 1 na tej liście to n+1.

Retina , 21 bajtów

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

Wypróbuj online! Moja pierwsza odpowiedź na siatkówkę z dwoma końcowymi znakami nowej linii! Objaśnienie: Pierwsze dwa wiersze są konwertowane z dziesiętnego na jednoargumentowy. Trzeci i czwarty wiersz odejmują dwa od liczb parzystych. Ostatni wiersz konwertuje z powrotem na dziesiętne, ale dodaje także jeden.

05AB1E , 4 bajty

(1^(

Wypróbuj online!

Cubix , 11 bajtów

u%2!I(/+@O<

Wypróbuj online!

Wyjaśnienie

Wersja netto:

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

Znaki są wykonywane w następującej kolejności:

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 bajtów

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

Wypróbuj online!

Jestem osobiście bardzo zadowolony z tej odpowiedzi, ponieważ jest ona znacznie krótsza niż to, co uważam za tradycyjną metodę rozwiązania tego problemu.

Wyjaśnienie

Pierwszy bit kodu

(({})(()))

konwertuje stos z tylko nna

n + 1
  1
  n

Następnie, gdy górna część stosu jest różna od zera, zmniejszamy ją i odwracamy pod nią znak liczby

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

Usuwamy zero i dodajemy dwie pozostałe liczby

{}({}{})

Matematyka, 22 19 bajtów

Zaoszczędzono 3 bajty dzięki Gregowi Martinowi!

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

Poprzednia odpowiedź, 22 bajty

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

Wyjaśnienie (dla poprzedniej odpowiedzi)

Mathematica ma tę fajną funkcję, że operacje takie jak arytmetyka automatycznie przewijają listy.

W tym przypadku bierzemy, Mod[#,2]która zwróci 0 lub 1, ale musimy dodać 1, ponieważ listy Mathematica są indeksowane 1. Jeśli jest parzysty , wynik jest równy 1, więc #-1jest zwracany. Jeśli jest nieparzysty , wynik jest równy 2, więc #+1jest zwracany.

Mądry , 8 bajtów

-::^~-^-

Wypróbuj online!

Wyjaśnienie

Gdyby było na odwrót (zmniejszenie, jeśli nieparzyste, zwiększenie, jeśli parzyste), byłoby to dość łatwe.

Przerzucilibyśmy ostatni kawałek.

::^~-^

Poprawka polega na tym, że odwracamy ostatni bit, gdy jest ujemny. Liczby ujemne są o 1 wyłączone od negacji liczb, ~więc tworzy to przesunięcie rozwiązujące problem.

Więc po prostu wyjmujemy program i owijamy go -.

-::^~-^-

Java 8, 16 10 bajtów

n->-(-n^1)

Java 7, 34 28 bajtów

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

Nudne porty niesamowitej odpowiedzi w języku C @feersum .
Wypróbuj tutaj.

Stare odpowiedzi:

Java 8, 16 bajtów

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

Java 7, 34 bajty

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

Objaśnienie (starej odpowiedzi Java 7):

Wypróbuj tutaj.

Powyższa odpowiedź jest krótszym wariantem polegającym int c(int n){return n%2<1?n-1:n+1;}na pozbyciu się przestrzeni.

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 bajtów

n ^1 n

Wypróbuj online!

Python, 20 bajtów

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

Befunge 93 , 18 bajtów

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

Nie skończyłem jeszcze gry w golfa (mam nadzieję).

Ruby, 12 bajtów

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

R, 17 bajtów

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

gdzie n=scan()bierze wartość cyfry.

Casio-Basic, 27 bajtów

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

26 bajtów dla funkcji, +1, aby wprowadzić nw polu parametrów.

C, 29 bajtów

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

Galaretka , 4 bajty

‘’Ḃ?

Wypróbuj online!

Partia, 20 bajtów

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

Niezależnie odkryłem ponownie algorytm @ feersum, szczerze!