Wprowadzenie

Normalna szachownica zawiera 8 x 8 = 64 kwadratów:

Widać, że w sumie jest 12 białych elementów . Czarno-białe zawsze mają tę samą ilość sztuk. Jeśli na planszy znajduje się więcej pionków, będą się one sąsiadować, co nie jest dozwolone w tym wyzwaniu. Aby to wyjaśnić, oto kilka przykładów:

Najmniejsza możliwa plansza do tego wyzwania to 3 x 3 :

Widać, że maksymalna ilość sztuk wynosi 2 . Tak więc, gdy podano N = 3 , musisz wyprowadzić 2 . Jeśli wartością wejściową jest N = 4 , otrzymujemy:

Widać, że maksymalna kwota wynosi również 2. Więc dla N = 4 , wynik powinien wynosić 2 . Dla N = 5 wynik powinien być równy 5 :

Przykłady

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

Zasady

• Twoje zgłoszenie musi być programem lub funkcją itp., Która pobiera jedną liczbę całkowitą i wysyła lub zwraca liczbę elementów na płycie
• Możesz bezpiecznie założyć, że wejście jest nieujemną liczbą całkowitą> 2
• To jest golf golfowy , więc wygrywa program z najmniejszą liczbą bajtów!
• Zauważ, że kwadrat w lewym dolnym rogu planszy jest zawsze ciemny. Kawałki są umieszczane tylko na ciemnych kwadratach
• Musisz zająć pełny rząd kawałkami

Par , 8 bajtów

✶″½↓┐*½┐

Jeden bajt jest używany na znak.

Wyjaśnienie

               ## [implicit: read line]      Example
✶              ## Convert to number           7
″              ## Duplicate                   7 7
½              ## Divide by two               7 3.5    half the board
↓              ## Minus one                   7 2.5    leave one row empty
┐              ## Ceiling                     7 3      a whole number of rows
*              ## Multiply                    21       total number of spaces
½              ## Divide by two               10.5     only the blue squares
┐              ## Ceiling                     11       starts with blue, so round up

Sześciokąt , 19 bajtów

?({{&2'2':{):!/)'*/

Wypróbuj online.

Wyjaśnienie

Jest to wciąż to samo obliczenie, którego użyłem w odpowiedziach na CJam i Labirynt, ale ze względu na ... specjalny ... model pamięci Hexagony'ego, trudniej jest wycisnąć obliczenie na 19 bajtów (tak, aby mieściło się w długość sześciokąta 3).

Podobnie jak moja odpowiedź z Labiryntu, kończy się to błędem dzielenia przez 0.

Oto rozwinięty kod:

Jak powiedziałem, kod jest całkowicie liniowy. Wykonaną ścieżkę można poskładać w kolejności szaro-fioletowo-zielono-czerwono-niebieska. Ścieżka faktycznie biegnie nieco dalej, dopóki nie trafi :w lewo. Usuwając /(co tylko przekierowuje przepływ sterowania), cały program rozwijany liniowo jest:

?({2':{)'*){&2':!:&?':

Pytanie brzmi, jak to działa. Pamięć sześciokąta jest wykresem liniowym siatki szesnastkowej, gdzie każda krawędź siatki zawiera wartość całkowitą (początkowo zero). Wskaźnik pamięci (MP) zawsze znajduje się na jednej krawędzi i wskazuje w określonym kierunku wzdłuż tej krawędzi. Operacje arytmetyczne na ogół stosuje się do dwóch krawędzi wskazanych w i przechowywane w krawędzi MP jest włączony.

W tym programie użyjemy trzech krawędzi oznaczonych A , B , C , przy czym MP rozpocznie się tak, jak pokazano tutaj:

Oto jak to działa:

?  Read an integer N from STDIN into edge A.
(  Decrement to get N-1.
{  Move the MP forwards onto edge B.
2  Set the edge to 2.
'  Move the MP backwards onto edge C.
:  Divide edge A by edge B (rounding down) to compute (N-1)/2.
{  Move the MP forwards onto edge A.
)  Increment to restore value of N.
'  Move the MP backwards onto edge B.
*  Multiply edges A and C to compute N*(N-1)/2.
)  Increment to compute N*(N-1)/2 + 1.
{  Move the MP forwards onto edge C.
&  This actually a copy operation, but we use it to reset the edge to zero.
2  Set the edge to 2.
'  Move the MP backwards onto edge A.
:  Divide edge B by edge C to compute (N*(N-1)/2 + 1)/2.
!  Output the result as an integer. We're basically done now.
:  no-op (we already have this value)
&  Copy either B or C into A (doesn't matter).
?  Read a zero (EOF) into A.
'  Move the MP backwards onto an unused cell.
:  Divide some unused cell by A (which is zero), terminating with an error.

LabVIEW, 28 20 LabVIEW Prymitywy

CJam, 10 bajtów

ri_(2/*)2/

Sprawdź to tutaj.

Wyjaśnienie

ri   e# Read input and convert to integer N.
_    e# Duplicate N.
(2/  e# Decrement, integer divide by two, to determine the number of rows that can be used.
*    e# Multiply by the input to determine the number of cells that can be used.
)2/  e# Increment, integer divide by two, which essentially ceil()s the result of the
     e# division.

Labirynt , 11 bajtów

Woohoo, tylko jeden bajt za CJam .

?:(#/*)_2/!

Wypróbuj online.

To w zasadzie to samo:

? reads an integer value.
: duplicates the result.
( decrements it.
# pushes the stack depth which happens to be 2.
/ is integer division.
* is multiplication.
) increments the result.
_ pushes a 0.
2 turns it into a 2.
/ is once again integer division.
! prints the result as an integer.

Jednak w tym momencie program jeszcze się nie kończy. Zamiast tego wskaźnik instrukcji uderzył w ślepy zaułek i odwrócił się. Ale teraz /próbuje obliczyć, 0/0która kończy się błędem .

Poważnie , 8 bajtów

,;D½L*½K

Poważnie ma przydatny ½(dzielnik zmiennoprzecinkowy przez 2) i K(pułap), więc nie musimy dodawać jednego przed dzieleniem.

Wypróbuj tutaj z wyjaśnieniem.

Python 2, 22 21 bajtów

lambda n:~-n/2*n+1>>1

Najpierw oddzielam w dwóch przypadkach, nieparzystym N, a nawet N.

Dziwnym N możemy wypełnić (N - 1) / 2 rzędy, zawierające średnio N / 2 sztuki. Ponieważ pierwszy rząd zawsze zawiera więcej elementów, ten wynik należy ograniczyć. Tak więc, gdy N jest nieparzyste, mamy kawałki sufitu ((N-1) / 2 * N / 2).

Nawet parzystym N możemy wypełnić N / 2 - 1 lub rzędy podłogi ((N - 1) / 2), każdy rząd zawiera N / 2 sztuki.

Możemy połączyć te dwa wyrażenia według sufitu (floor ((N-1) / 2) * N / 2). Ponieważ ceil (x / 2) = podłogi ((X + 1) / 2), można użyć podłogi podział: ((N - 1) // 2 * N + 1) // 2.

JavaScript, 37 35 bajtów

alert(((n=prompt()/2)-.5|0)*n+.5|0)

Wyjaśnienie

Używa techniki podobnej do pozostałych odpowiedzi. To jest algorytm bez golfa:

var n = parseInt(prompt());
var result = Math.ceil(Math.floor((n - 1) / 2) * n / 2);
alert(result);

dc, 12

?d1-2/*1+2/p

Wyjście testowe:

$ for t in 3 4 5 6 8; do echo $t | dc -e?d1-2/*1+2/p; done
2
2
5
6
12
$ 

Pyth, 9 bajtów

/h*/tQ2Q2

Ten sam algorytm, co moja odpowiedź w języku Python 2.

Japt , 16 14 bajtów

U-1>>1 *U+1>>1

Wypróbuj online!

Jak to działa

Dość proste:

         // Implicit: U = input number
U-1>>1   // Subtract 1 from U and integer divide by 2.
*U+1>>1  // Multiply the result by U, add 1, and integer divide by 2.
         // Implicit: output last expression

Chciałbym, aby był jakiś sposób, aby wziąć pod uwagę, że dwie połówki kodu są tak podobne. Sugestie mile widziane!

Stara wersja (16 bajtów):

U*½-½|0 *U*½+½|0

Java, 230 155 52

Gra w golfa:

int f(int s){return(int)Math.ceil(s*((s-1)/2)/2.0);}

Nie golfowany:

public class NumberOfPiecesOnACheckersBoard {

  public static void main(String[] args) {
    // @formatter:off
    int[][] testData = new int[][] {
      {3, 2},
      {4, 2},
      {5, 5},
      {6, 6},
      {8, 12}
    };
    // @formatter:on

    for (int[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new NumberOfPiecesOnACheckersBoard().f(data[0]));
      System.out.println();
    }
  }

  // Begin golf
  int f(int s) {
    return (int) Math.ceil(s * ((s - 1) / 2) / 2.0);
  }
  // End golf

}

Wyjście programu:

Input: 3
Expected: 2
Actual:   2

Input: 4
Expected: 2
Actual:   2

Input: 5
Expected: 5
Actual:   5

Input: 6
Expected: 6
Actual:   6

Input: 8
Expected: 12
Actual:   12

Kod maszynowy Zilog ez80, 9 bajtów

W hex:

6C 2D CB3D ED6C 2C CB3D

W montażu:

ld l,h
dec l
srl l
mlt hl
inc l
srl l

Wejście jest w rejestrze h, a wyjście jest wl .

Zilog ez80 to 8-bitowy procesor z 8-bitowym akumulatorem i rejestrami 24-bitowymi. W przeciwieństwie do Z80 mamlt instrukcję (8-bitowe zwielokrotnienie), która w trybie 16-bitowym mnoży tutaj wysokie i niskie bajty pary rejestrów hli zapisuje z powrotem whl .

Działa to tylko w przypadku wartości, dla których dwukrotność wyniku mieści się w 8 bitach; to jest, n ≤23.

TI-BASIC, 13 bajtów

⁻int(⁻.5Ansint(Ans/2-.5

Ukryte mnożenie TI-BASICA pomaga, ale nie ma podziału na liczby całkowite. ⁻int(⁻Xjest krótszą formą ceil (x).

vba, 46

Function f(x)
f=(((x-1)\2)*x+1)\2
End Function

Wywołaj za pomocą? F (x) lub = f (A1) we wzorze

Pyth, 17 14 13 bajtów

-3 bajty dzięki Ypnypn ! Zmieniono numery operatora *, aby zaoszczędzić 1 bajt.

/+*Q-/Q2-1%Q2 1 2 (original)
/h*Q-/Q2!%Q2 2
/h*-/Q2!%Q2Q2

Wyjaśnienie:

Kiedy n jest parzyste, możemy zajmować n / 2-1 wierszy z n / 2 kawałkami, co daje w sumie n * (n / 2-1) / 2 kawałki. To wyrażenie jest równoważne (n * (n / 2-1) +1) / 2

Gdy n jest nieparzyste, możemy dowiedzieć się, jak dwa razy będzie wyglądała liczba sztuk, dwa razy liczba elementów obejmie n-1 rzędy, a jeśli zabiorę jeden kawałek, możemy podzielić n-1 rzędy na (n- 1) / 2 grupy po 2 rzędy, tak że każda grupa ma n elementów, więc wyrażenie dla tego przypadku to (n * (n / 2) +1) / 2

Teraz, gdy oba wyrażenia są dość podobne, możemy napisać kod.

/h*-/Q2!%Q2Q2
        %Q2   Check if the number is odd
       !      Logical not to make 1 if even and 0 if odd
    /Q2       n/2
   -          n/2-1 if even, and n/2 if odd
  *        Q  n*(n/2-1) if even, n*(n/2) if odd
 h            Add one
/           2 Divide the result by two.

Pierwszy raz używałem języka golfowego.

JavaScript, 33 bajty

a=prompt();alert(a*(a-1>>1)+1>>1)

Jeśli funkcja ES6 jest dozwolona, ​​to 18 bajtów:

a=>a*(a-1>>1)+1>>1

MATLAB, 37 25 bajtów

@(a)ceil(fix(a/2-.5)*a/2)

Wierzę, że to powinno działać, działa dla wszystkich przypadków testowych.

Działa również na Octave . Możesz spróbować online tutaj .

Do starego kodu dodałem program do tego obszaru roboczego w pliku o nazwie checkerboard.m. Możesz go uruchomić, po prostu wprowadzająccheckerboard monit, a następnie, gdy się uruchomi, wprowadź wymagany rozmiar w monicie. Wynik zostanie wydrukowany.

W przypadku nowego kodu wystarczy wpisać kod opublikowany tutaj w wierszu polecenia, a następnie wywołać funkcję anonimową jako ans(n).

Siatkówka , 18 bajtów

11(..?$)?
$_
11?
1

Wejście i wyjście jest jednoargumentowe .

Wypróbuj online!

Najnowsza wersja Retina (nowsza niż to wyzwanie) może obsługiwać dziesiętne operacje we / wy dla czterech dodatkowych bajtów:

.+
$*
11(..?$)?
$_
11?

Wypróbuj online!

Dzięki jednemu wprowadzeniu i wyjściu dziesiętnemu możemy zrobić 16 bajtów, ale wydaje się to trochę rozciągnięte:

11(..?$)?
$_
11?

Wyjaśnienie

Nadal takie samo podejście, jak ktokolwiek inny, ale przy użyciu zastępowania wyrażenia regularnego na jednostkowej reprezentacji liczby.

11(..?$)?
$_

To się oblicza n*((n-1)/2). Robimy to, dopasowując dwa znaki na raz (dzielenie przez dwa) i zamieniając je na cały ciąg (mnożenie przez n). Zmniejszenia ndokonuje się, pomijając resztę ciągu, jeśli pozostanie tylko jeden lub dwa znaki.

11?
1

Jest to dzielenie liczb całkowitych przez 2, zaokrąglone w górę. Po prostu zamieniamy dwie postacie na jedną (dzielenie przez 2), ale pozwalamy, aby ostatnie dopasowanie składało się tylko z jednej postaci (zaokrąglanie w górę).

Python 3, 39 bajtów

To jest trochę rozdęte, ale nie jestem pewien, czy mógłbym grać w golfa znacznie dalej. Link do testowania.

n=int(input());print(((n-1)//2*n+1)//2)

Prolog, 39 38 bajtów

Kod:

p(N):-X is ((N-1)//2*N+1)//2,write(X).

Wyjaśnienie:

Subtract 1 from input and integer divide by 2 to get number of rows available.
Multiply that number by input to get number of squares available. 
Add one and integer divide by 2 to round up, since at at least half the rows 
will have a checker at the first square.
Print.

Przykład:

p(8).
12

Wypróbuj online tutaj

Edycja: Zapisano 1 bajt, zastępując ceil / 2 + 1 // 2

Świnka, 17 bajtów

R I W I-1\2*I+1\2

Dzięki Emignie za proste wyjaśnienie algorytmu. Wykorzystuje to „niedobór” matematyki Mumpsa polegający na tym, że operacje są wykonywane ściśle od lewej do prawej (nie PEMDAS), więc nawiasy nie są wymagane. :-)

Dane wyjściowe wyglądają jednak trochę dziwnie, ponieważ Cache's Ensemble (środowisko Mumps, do którego mam dostęp) nie wyświetla automatycznie powrotu karetki nawet po naciśnięciu na wejściu. Jeśli chcesz ładniej, dodaj 4 znaki dla zwrotów przed / po przewozie:

R I W !,I-1\2*I+1\2,!

Dzięki!

Bash, 32 bajty

read a;echo $((a*(a-1>>1)+1>>1))

Pyke, 8 bajtów, niekonkurujące

Dt2f*h2f

dup, dec, half, mult, inc, half

Wypróbuj tutaj!

Partia, 30 bajtów

@cmd/cset/a(%1*((%1-1)/2)+1)/2

38 bajtów, jeśli wymagane jest wejście standardowego wejścia:

@set/pa=
@cmd/cset/a(a*((a-1)/2)+1)/2