introduzione

Una normale scacchiera contiene 8 x 8 = 64 quadrati:

Puoi vedere che in totale ci sono 12 pezzi bianchi . Il bianco e nero ha sempre la stessa quantità di pezzi. Se ci sono altri pezzi sul tabellone, i pezzi sarebbero vicini, cosa non consentita per questa sfida. Per chiarire le cose, ecco alcuni esempi:

La tavola più piccola possibile per questa sfida è 3 x 3 :

Puoi vedere che la quantità massima di pezzi è uguale a 2 . Quindi, quando viene dato N = 3 , è necessario produrre 2 . Se l'input è N = 4 , otteniamo quanto segue:

Puoi vedere che anche l'importo massimo è 2. Quindi per N = 4 , l'output dovrebbe essere 2 . Per N = 5 , l'uscita dovrebbe essere uguale a 5 :

Esempi

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

Regole

• Il tuo invio deve essere un programma o una funzione ecc. Che richiede un numero intero e genera o restituisce il numero di pezzi sul tabellone
• Si può presumere che l'input sia un numero intero non negativo> 2
• Questo è code-golf , quindi vince il programma con il minor numero di byte!
• Nota che il quadrato nell'angolo in basso a sinistra del tabellone è sempre scuro. I pezzi vengono posizionati solo su quadrati scuri
• Devi occupare una fila intera con pezzi

Par , 8 byte

✶″½↓┐*½┐

Viene utilizzato un byte per carattere.

Spiegazione

               ## [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

Esagonia , 19 byte

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

Provalo online.

Spiegazione

Questo è ancora lo stesso calcolo che ho usato nelle mie risposte CJam e Labyrinth, ma a causa del modello di memoria ... speciale ... di Hexagony, è un po 'più complicato comprimere il calcolo in 19 byte (in modo che rientri in un 3 lati esagonali).

Come la mia risposta Labyrinth, questo termina con un errore di divisione per 0.

Ecco il codice spiegato:

Come ho detto, il codice è del tutto lineare. Puoi mettere insieme il percorso eseguito nell'ordine grigio-viola-verde-rosso-blu. Il percorso in realtà continua ancora un po 'fino a quando non colpisce :a sinistra. Rimuovendo il /(che reindirizza solo il flusso di controllo), l'intero programma svolto in modo lineare è:

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

Quindi la domanda è come funziona. La memoria di Hexagony è il grafico a linee di una griglia esadecimale, in cui ciascun bordo della griglia contiene un valore intero (inizialmente zero). Il puntatore di memoria (MP) si trova sempre su un bordo e punta in una certa direzione lungo quel bordo. Operazioni aritmetiche vengono generalmente applicati ai due spigoli appuntiti a e memorizzati nel bordo MP è acceso.

Per questo programma, utilizzeremo i tre bordi etichettati A , B , C , con l'MP che inizia come mostrato qui:

Quindi ecco come funziona:

?  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 Primitives

CJam, 10 byte

ri_(2/*)2/

Provalo qui.

Spiegazione

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.

Labyrinth , 11 byte

Woohoo, solo un byte dietro CJam .

?:(#/*)_2/!

Provalo online.

È essenzialmente la stessa cosa:

? 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.

Tuttavia, a questo punto il programma non termina ancora. Invece, il puntatore dell'istruzione ha raggiunto un vicolo cieco e si gira. Ma ora /prova a calcolare 0/0che termina con un errore .

Scherzi a parte , 8 byte

,;D½L*½K

Seriamente ha il pratico ½(float divide per 2) eK (soffitto), quindi non è necessario aggiungerne uno prima della divisione.

Provalo qui con una spiegazione.

Python 2, 22 21 byte

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

Prima separo in due casi, N dispari e persino N.

Con N dispari possiamo riempire (N - 1) / 2 righe, contenenti in media N / 2 pezzi. Dato che la prima fila ha sempre più pezzi, dovremmo confermare questo risultato. Quindi quando N è dispari abbiamo pezzi ceil ((N-1) / 2 * N / 2).

Con N pari possiamo riempire N / 2 - 1, o file del pavimento ((N - 1) / 2), ogni riga contenente N / 2 pezzi.

Possiamo combinare queste due espressioni per ceil (floor ((N-1) / 2) * N / 2). Dal momento che ceil (x / 2) = piano ((x + 1) / 2) possiamo usare pavimenti divisione: ((N - 1) // 2 * N + 1) // 2.

JavaScript, 37 35 byte

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

Spiegazione

Utilizza una tecnica simile al resto delle risposte. Questo è l'algoritmo non golfato:

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

dc, 12

?d1-2/*1+2/p

Uscita di prova:

$ 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 byte

/h*/tQ2Q2

Stesso algoritmo della mia risposta Python 2.

Japt , 16 14 byte

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

Provalo online!

Come funziona

Abbastanza semplice:

         // 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

Vorrei che ci fosse un modo per tenere conto del fatto che le due metà del codice sono così simili. Suggerimenti benvenuti!

Vecchia versione (16 byte):

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

Java, 230 155 52

golfed:

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

Ungolfed:

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

}

Uscita del programma:

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

Codice macchina Zilog ez80, 9 byte

In esadecimale:

6C 2D CB3D ED6C 2C CB3D

Nel montaggio:

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

L'ingresso è nel registro he l'uscita è dentrol .

Zilog ez80 è un processore a 8 bit con un accumulatore a 8 bit e registri a 24 bit. A differenza dello z80, ha un'istruzione mlt(moltiplicazione di 8 bit), che, in modalità 16 bit, moltiplica i byte alto e basso di una coppia di registri, qui hl, e memorizza nuovamente inhl .

Funziona solo con valori per i quali il doppio del risultato si adatta a 8 bit; cioè n≤23.

TI-BASIC, 13 byte

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

La moltiplicazione implicita di TI-BASIC aiuta, ma non ha divisione intera. ⁻int(⁻Xè una forma più corta di ceil (x).

vba, 46

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

Chiama con? F (x) o = f (A1) in una formula

Pyth, 17 14 13 byte

-3 byte grazie a Ypnypn ! Riorganizzato i numeri dell'operatore * per salvare 1 byte.

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

Spiegazione:

Quando n è pari, possiamo occupare n / 2-1 file con n / 2 pezzi, per un totale di n * (n / 2-1) / 2 pezzi. Questa espressione è equivalente a (n * (n / 2-1) +1) / 2

Quando n è dispari, possiamo scoprire come dovrebbe essere il doppio del numero di pezzi, il doppio del numero di pezzi si estenderà su n-1 file e se toglierò un pezzo, possiamo dividere le n-1 file in (n- 1) / 2 gruppi di 2 file in modo tale che ogni gruppo abbia n pezzi, quindi l'espressione per questo caso è (n * (n / 2) +1) / 2

Ora che entrambe le espressioni sono abbastanza simili, possiamo scrivere il codice.

/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.

La mia prima volta che utilizzo un linguaggio da golf.

Javascript, 33 byte

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

Se è consentita una funzione ES6, 18 byte:

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

MATLAB, 37 25 byte

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

Credo che questo dovrebbe funzionare, funziona per tutti i casi di test.

Funziona anche su Octave . Puoi provare online qui .

Per il vecchio codice ho aggiunto il programma a quell'area di lavoro in un file denominato checkerboard.m. Puoi eseguirlo semplicemente inserendocheckerboard al prompt, quindi quando si avvia, immettere la dimensione richiesta al prompt. Il risultato verrà stampato.

Per il nuovo codice, inserisci semplicemente il codice pubblicato qui nel prompt, quindi chiama la funzione anonima come ans(n).

Retina , 18 byte

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

Ingresso e uscita sono unari .

Provalo online!

L'ultima versione di Retina (più recente di questa sfida) potrebbe gestire I / O decimali per quattro byte aggiuntivi:

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

Provalo online!

Con input unario e output decimale, possiamo fare 16 byte, ma sembra un po 'allungato:

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

Spiegazione

Sempre lo stesso approccio di chiunque altro, ma usando la sostituzione regex su una rappresentazione unaria del numero.

11(..?$)?
$_

Questo calcola n*((n-1)/2). Lo facciamo abbinando due caratteri alla volta (divisione per due) e sostituendoli con l'intera stringa (moltiplicazione per n). Il decremento di nviene fatto saltando il resto della stringa, se rimangono solo uno o due caratteri.

11?
1

Questa è una divisione intera per 2, arrotondata per eccesso. Sostituiamo semplicemente due personaggi con uno (divisione per 2), ma permettiamo che l'ultima partita sia composta da un solo personaggio (arrotondamento per eccesso).

Python 3, 39 byte

Questo è un po 'gonfio, ma non sono sicuro di poter giocare a golf molto oltre. Un collegamento per i test.

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

Prolog, 39 38 byte

Codice:

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

Spiegazione:

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.

Esempio:

p(8).
12

Provalo online qui

Modifica: 1 byte salvato sostituendo ceil / 2 con + 1 // 2

Parotite, 17 byte

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

Grazie a Emigna per la semplice spiegazione dell'algoritmo. Ciò sfrutta la "carenza" matematica di Mumps secondo la quale le operazioni vengono eseguite rigorosamente da sinistra a destra (non PEMDAS), pertanto non è necessaria la parentesi. :-)

L'output sembra un po 'strano, tuttavia, poiché Cache's Ensemble (l'ambiente Mumps a cui ho accesso) non genera automaticamente ritorni a capo del carrello anche se premuto sull'input. Se lo desideri più carino, aggiungi 4 caratteri per i ritorni a capo pre / post:

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

Grazie!

Bash, 32 byte

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

Pyke, 8 byte, non competitivo

Dt2f*h2f

DUP, dicembre, la metà, mult, inc, la metà

Provalo qui!

Lotto, 30 byte

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

38 byte se è richiesto l'input su stdin:

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