introduction

Un damier normal contient 8 x 8 = 64 carrés:

Vous pouvez voir qu'au total, il y a 12 pièces blanches . Le noir et le blanc ont toujours la même quantité de pièces. S'il y a plus de pièces sur le plateau, les pièces seraient voisines, ce qui n'est pas autorisé pour ce défi. Pour clarifier les choses, voici quelques exemples:

La planche la plus petite possible pour ce défi est 3 x 3 :

Vous pouvez voir que le nombre maximum de pièces est égal à 2 . Donc, lorsque N = 3 , vous devez sortir 2 . Si l'entrée est N = 4 , nous obtenons ce qui suit:

Vous pouvez voir que le montant maximum est également 2. Donc, pour N = 4 , la sortie doit être 2 . Pour N = 5 , la sortie doit être égale à 5 :

Exemples

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

Règles

• Votre soumission doit être un programme, une fonction, etc. qui prend un entier et génère ou renvoie le nombre de pièces sur le tableau
• Vous pouvez supposer en toute sécurité que l'entrée est un entier non négatif> 2
• C'est du code-golf , donc le programme avec le moins d'octets gagne!
• Notez que le carré en bas à gauche du tableau est toujours sombre. Les pièces ne sont placées que sur des carrés sombres
• Vous devez occuper une rangée complète avec des morceaux

Par , 8 octets

✶″½↓┐*½┐

Un octet est utilisé par caractère.

Explication

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

Hexagonie , 19 octets

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

Essayez-le en ligne.

Explication

C'est toujours le même calcul que celui que j'ai utilisé dans mes réponses CJam et Labyrinth, mais en raison du modèle de mémoire ... spécial ... d'Hexagony, il est un peu plus difficile de compresser le calcul en 19 octets (pour qu'il tienne dans un côté 3 hexagone).

Comme ma réponse Labyrinth, cela se termine par une erreur de division par 0.

Voici le code déplié:

Comme je l'ai dit, le code est entièrement linéaire. Vous pouvez reconstituer le chemin exécuté dans l'ordre gris-violet-vert-rouge-bleu. Le chemin continue en fait un peu plus loin jusqu'à ce qu'il atteigne :la gauche. En supprimant le /(qui ne redirige que le flux de contrôle), l'ensemble du programme déroulé linéairement est:

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

La question est donc de savoir comment cela fonctionne. La mémoire de l'hexagonie est le graphique linéaire d'une grille hexadécimale, où chaque bord de la grille contient une valeur entière (initialement zéro). Le pointeur de mémoire (MP) est toujours sur un bord et pointe dans une certaine direction le long de ce bord. Les opérations arithmétiques sont généralement appliqués sur les deux bords pointus à et stockées dans le bord de la MP est en marche.

Pour ce programme, nous utiliserons les trois bords étiquetés A , B , C , le MP commençant comme indiqué ici:

Voici donc comment cela fonctionne:

?  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 primitives LabVIEW

CJam, 10 octets

ri_(2/*)2/

Testez-le ici.

Explication

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.

Labyrinthe , 11 octets

Woohoo, un seul octet derrière CJam .

?:(#/*)_2/!

Essayez-le en ligne.

C'est essentiellement la même chose:

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

Cependant, à ce stade, le programme ne se termine pas encore. Au lieu de cela, le pointeur d'instruction a atteint une impasse et se retourne. Mais /essaie maintenant de calculer 0/0ce qui se termine par une erreur .

Sérieusement , 8 octets

,;D½L*½K

A sérieusement la maniabilité ½ (float diviser par 2), et K(plafond), donc nous n'avons pas besoin d'en ajouter un avant la division.

Essayez-le ici avec explication.

Python 2, 22 21 octets

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

Je sépare d'abord dans deux cas, N impair et même N.

Avec un N impair, nous pouvons remplir (N - 1) / 2 lignes, contenant en moyenne N / 2 pièces. Puisque la première rangée a toujours plus de pièces, nous devrions plafonner ce résultat. Ainsi, lorsque N est impair, nous avons des pièces de plafond ((N-1) / 2 * N / 2).

Avec même N, nous pouvons remplir N / 2 - 1, ou les rangées de plancher ((N - 1) / 2), chaque ligne contenant N / 2 pièces.

Nous pouvons combiner ces deux expressions par ceil (floor ((N-1) / 2) * N / 2). Depuis Ceil (x / 2) = étage ((x + 1) / 2) , nous pouvons utiliser la division revêtement de sol: ((N - 1) // 2 * N + 1) // 2.

JavaScript, 37 35 octets

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

Explication

Utilise une technique similaire au reste des réponses. Voici l'algorithme non golfé:

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

dc, 12

?d1-2/*1+2/p

Sortie de test:

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

/h*/tQ2Q2

Même algorithme que ma réponse Python 2.

Japt , 16 14 octets

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

Essayez-le en ligne!

Comment ça fonctionne

Assez simple:

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

Je souhaite qu'il y ait un moyen de tenir compte du fait que les deux moitiés du code sont si similaires. Suggestions bienvenues!

Ancienne version (16 octets):

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

Java, 230 155 52

Golfé:

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

Non golfé:

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

}

Sortie du programme:

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

Code machine Zilog ez80, 9 octets

En hex:

6C 2D CB3D ED6C 2C CB3D

En montage:

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

L'entrée est dans le registre het la sortie est dansl .

Le Zilog ez80 est un processeur 8 bits avec un accumulateur 8 bits et des registres 24 bits. Contrairement au z80, il a unmlt instruction (multiplication sur 8 bits) qui, en mode 16 bits, multiplie les octets haut et bas d'une paire de registres, ici hl, et les stocke à nouveau hl.

Cela ne fonctionne que pour les valeurs pour lesquelles le résultat deux fois tient sur 8 bits; c'est-à-dire, n≤23.

TI-BASIC, 13 octets

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

La multiplication implicite de TI-BASIC aide, mais elle n'a pas de division entière. ⁻int(⁻Xest une forme de plafond plus courte (x).

vba, 46

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

Appelez avec? F (x), ou = f (A1) dans une formule

Pyth, 17 14 13 octets

-3 octets grâce à Ypnypn ! Réorganisé les numéros de l'opérateur * pour enregistrer 1 octet.

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

Explication:

Lorsque n est pair, nous pouvons occuper n / 2-1 rangées avec n / 2 pièces, soit un total de n * (n / 2-1) / 2 pièces. Cette expression est équivalente à (n * (n / 2-1) +1) / 2

Lorsque n est impair, nous pouvons trouver à quoi ressemblerait deux fois le nombre de pièces, deux fois le nombre de pièces s'étendra sur n-1 lignes, et si j'en retire une pièce, nous pouvons diviser les n-1 lignes en (n- 1) / 2 groupes de 2 rangées de sorte que chaque groupe a n morceaux, donc l'expression pour ce cas est (n * (n / 2) +1) / 2

Maintenant que les deux expressions sont assez similaires, nous pouvons écrire le code.

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

Ma première fois en utilisant une langue de golf.

Javascript, 33 octets

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

Si une fonction ES6 est autorisée, alors 18 octets:

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

MATLAB, 37 25 octets

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

Je crois que cela devrait fonctionner, pour tous les cas de test.

Il fonctionne également sur Octave . Vous pouvez essayer en ligne ici .

Pour l'ancien code, j'ai ajouté le programme à cet espace de travail dans un fichier nommé checkerboard.m. Vous pouvez l'exécuter en entrant simplementcheckerboard à l'invite, puis lorsqu'il démarre, entrez la taille requise à l'invite. Le résultat sera imprimé.

Pour le nouveau code, entrez simplement le code affiché ici dans l'invite, puis appelez la fonction anonyme sous ans(n).

Rétine , 18 octets

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

L'entrée et la sortie sont unaires .

Essayez-le en ligne!

La dernière version de Retina (plus récente que ce défi) pouvait gérer les E / S décimales pour quatre octets supplémentaires:

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

Essayez-le en ligne!

Avec une entrée unaire et une sortie décimale, nous pouvons faire 16 octets, mais cela semble un peu exagéré:

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

Explication

Toujours la même approche que n'importe qui d'autre, mais en utilisant le remplacement d'expression régulière sur une représentation unaire du nombre.

11(..?$)?
$_

Cela calcule n*((n-1)/2). Nous faisons cela en faisant correspondre deux caractères à la fois (division par deux) et en les remplaçant par la chaîne entière (multiplication par n). La décrémentation de nse fait en ignorant le reste de la chaîne, s'il ne reste qu'un ou deux caractères.

11?
1

Il s'agit d'une division entière par 2, arrondie. Nous remplaçons simplement deux caractères par un (division par 2), mais permettons au dernier match de se composer d'un seul caractère (arrondi).

Python 3, 39 octets

C'est un peu gonflé, mais je ne suis pas sûr de pouvoir jouer au golf beaucoup plus loin. Un lien pour les tests.

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

Prolog, 39 38 octets

Code:

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

Explication:

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.

Exemple:

p(8).
12

Essayez-le en ligne ici

Edit: enregistré 1 octet en remplaçant ceil / 2 par + 1 // 2

Oreillons, 17 octets

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

Merci à Emigna pour l'explication simple de l'algorithme. Cela exploite la "déficience" mathématique de Mumps, car les opérations sont exécutées strictement de gauche à droite (pas PEMDAS), de sorte qu'aucune parenthèse n'est requise. :-)

La sortie semble un peu étrange, cependant, car l'Ensemble de Cache (l'environnement Mumps auquel j'ai accès) ne génère pas automatiquement de retours de chariot même lorsqu'il est pressé en entrée. Si vous le voulez plus joli, ajoutez 4 caractères pour les retours pré / post chariot:

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

Merci!

Bash, 32 octets

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

Pyke, 8 octets, sans concurrence

Dt2f*h2f

dup, dec, moitié, mult, inc, moitié

Essayez-le ici!

Lot, 30 octets

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

38 octets si une entrée sur stdin est requise:

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