Einführung

Ein normales Schachbrett enthält 8 x 8 = 64 Felder:

Sie können sehen, dass es insgesamt 12 weiße Stücke gibt . Schwarz und Weiß haben immer die gleiche Stückzahl. Wenn sich mehr Steine ​​auf dem Brett befinden, würden die Steine ​​benachbart sein, was für diese Herausforderung nicht zulässig ist. Zur Verdeutlichung hier einige Beispiele:

Das kleinstmögliche Brett für diese Herausforderung ist 3 x 3 :

Sie können sehen, dass die maximale Stückzahl 2 beträgt . Wenn also N = 3 ist , müssen Sie 2 ausgeben . Wenn die Eingabe N = 4 ist , erhalten wir Folgendes:

Sie können sehen, dass der maximale Betrag auch 2 ist. Für N = 4 sollte die Ausgabe 2 sein . Für N = 5 sollte die Ausgabe gleich 5 sein :

Beispiele

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

Regeln

• Ihr Beitrag muss ein Programm oder eine Funktion sein, die eine ganze Zahl annimmt und die Anzahl der Teile auf der Tafel ausgibt oder zurückgibt
• Sie können davon ausgehen, dass die Eingabe eine nicht negative Ganzzahl> 2 ist
• Das ist Code-Golf , also gewinnt das Programm mit der geringsten Anzahl von Bytes!
• Beachten Sie, dass das Quadrat unten links auf der Tafel immer dunkel ist. Stücke werden nur auf dunkle Quadrate gelegt
• Sie müssen eine volle Reihe mit Stücken besetzen

Par , 8 Bytes

✶″½↓┐*½┐

Pro Zeichen wird ein Byte verwendet.

Erläuterung

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

Hexagony , 19 Bytes

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

Probieren Sie es online aus.

Erläuterung

Dies ist immer noch die gleiche Berechnung, die ich in meinen CJam - und Labyrinth - Antworten verwendet habe, aber aufgrund des ... speziellen ... Speichermodells von Hexagony ist es etwas schwieriger, die Berechnung in 19 Byte zu zerlegen (so dass sie in ein passt) Seitenlänge 3 Sechseck).

Wie meine Labyrinth-Antwort endet dies mit einem Division-durch-0-Fehler.

Hier ist der entfaltete Code:

Wie gesagt der Code ist ganz linear. Sie können den ausgeführten Pfad in der Reihenfolge Grau-Lila-Grün-Rot-Blau zusammensetzen. Der Weg geht tatsächlich noch ein Stück weiter, bis er :auf der linken Seite trifft . Entfernen der /(die nur Steuerfluss umleiten), ist das gesamte Programm linear abgewickelt:

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

Die Frage ist also, wie es funktioniert. Der Speicher von Hexagony ist das Liniendiagramm eines Hex-Gitters, wobei jede Kante des Gitters einen ganzzahligen Wert enthält (anfangs Null). Der Speicherzeiger (MP) befindet sich immer auf einer Kante und zeigt in eine bestimmte Richtung entlang dieser Kante. Arithmetische Operationen werden an den beiden Rändern allgemein angewendet spitz auf und in dem Rand der gespeicherten MP eingeschaltet ist.

Für dieses Programm verwenden wir die drei mit A , B , C gekennzeichneten Kanten , wobei der MP wie folgt beginnt:

So funktioniert das:

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

CJam, 10 Bytes

ri_(2/*)2/

Teste es hier.

Erläuterung

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 Bytes

Woohoo, nur ein Byte hinter CJam .

?:(#/*)_2/!

Probieren Sie es online aus.

Es ist im Wesentlichen dasselbe:

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

Zu diesem Zeitpunkt wird das Programm jedoch noch nicht beendet. Stattdessen hat der Befehlszeiger eine Sackgasse erreicht und dreht sich um. Nun wird aber /versucht zu berechnen, 0/0was mit einem Fehler endet .

Im Ernst , 8 Bytes

,;D½L*½K

Im Ernst, hat das Handy ½(float dividieren durch 2) und K(Decke), so dass wir nicht vor der Division eine hinzufügen müssen.

Probieren Sie es hier mit Erklärung.

Python 2, 22 21 Bytes

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

Ich trenne zuerst in zwei Fällen, ungerade N und gerade N.

Mit ungeraden N können wir (N - 1) / 2 Reihen füllen, die durchschnittlich N / 2 Teile enthalten. Da die erste Reihe immer mehr Teile hat, sollten wir dieses Ergebnis begrenzen. Wenn also N ungerade ist, haben wir ceil ((N-1) / 2 * N / 2) Stücke.

Mit geradem N können wir N / 2 - 1 oder Boden ((N - 1) / 2) Zeilen füllen, wobei jede Zeile N / 2 Teile enthält.

Wir können diese beiden Ausdrücke nach ceil (floor ((N-1) / 2) * N / 2) kombinieren. Da ceil (x / 2) = floor ((x + 1) / 2) wir verwenden können Teilung Bodenbelag: ((N - 1) // 2 * N + 1) // 2.

JavaScript, 37-35 Bytes

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

Erläuterung

Verwendet eine ähnliche Technik wie die übrigen Antworten. Dies ist der ungolfed Algorithmus:

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

dc, 12

?d1-2/*1+2/p

Testausgang:

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

/h*/tQ2Q2

Gleicher Algorithmus wie meine Python 2-Antwort.

Japt , 16 14 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Ziemlich einfach:

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

Ich wünschte, es gäbe eine Möglichkeit zu berücksichtigen, dass die beiden Hälften des Codes so ähnlich sind. Vorschläge willkommen!

Alte Version (16 Bytes):

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

Java, 230, 155 52

Golf gespielt:

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

}

Programmausgabe:

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

Zilog ez80 Maschinencode, 9 Bytes

In hex:

6C 2D CB3D ED6C 2C CB3D

In Montage:

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

Eingang ist im Register hund Ausgang ist inl .

Der Zilog ez80 ist ein 8-Bit-Prozessor mit einem 8-Bit-Akkumulator und 24-Bit-Registern. Im Gegensatz zum z80 verfügt er über einen mlt(8-Bit-Multiplikations-) Befehl, der im 16-Bit-Modus die High- und Low-Bytes eines Registerpaars hier multipliziert hlund wieder speichert hl.

Dies funktioniert nur für Werte, für die das doppelte Ergebnis in 8 Bits passt. das heißt, n ≤ 23.

TI-BASIC, 13 Bytes

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

Die implizite Multiplikation von TI-BASIC hilft, hat aber keine Ganzzahldivision. ⁻int(⁻Xist eine kürzere Form von ceil (x).

VBA, 46

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

Rufen Sie mit? F (x) oder = f (A1) in einer Formel auf

Pyth, 17 14 13 Bytes

-3 Bytes dank Ypnypn ! Die Nummern des Operators * wurden neu angeordnet, um 1 Byte zu sparen.

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

Erläuterung:

Wenn n gerade ist, können wir n / 2-1 Reihen mit n / 2 Teilen belegen, was insgesamt n * (n / 2-1) / 2 Teilen ergibt. Dieser Ausdruck entspricht (n * (n / 2-1) +1) / 2

Wenn n ungerade ist, können wir herausfinden, wie doppelt so viele Teile aussehen würden, doppelt so viele Teile werden n-1 Reihen umfassen, und wenn ich ein Teil wegnehme, können wir die n-1 Reihen in (n- 1) / 2 Gruppen von 2 Reihen, so dass jede Gruppe n Teile hat, daher lautet der Ausdruck für diesen Fall (n * (n / 2) +1) / 2

Nachdem beide Ausdrücke sehr ähnlich sind, können wir den Code schreiben.

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

Ich habe zum ersten Mal eine Golfsprache verwendet.

Javascript, 33 Bytes

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

Wenn eine ES6-Funktion erlaubt ist, dann 18 Bytes:

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

MATLAB, 37 25 Bytes

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

Ich glaube, das sollte funktionieren, gilt für alle Testfälle.

Es funktioniert auch auf Octave . Sie können es hier online versuchen .

Für den alten Code habe ich das Programm zu diesem Arbeitsbereich in einer Datei mit dem Namen hinzugefügt checkerboard.m. Sie können es ausführen, indem Sie einfach checkerboardan der Eingabeaufforderung eingeben. Wenn es gestartet wird, geben Sie an der Eingabeaufforderung die erforderliche Größe ein. Das Ergebnis wird gedruckt.

Geben Sie für den neuen Code einfach den hier angegebenen Code in die Eingabeaufforderung ein und rufen Sie die anonyme Funktion als auf ans(n).

Retina , 18 Bytes

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

Ein- und Ausgang ist unär .

Probieren Sie es online!

Die neueste Version von Retina (neuer als diese Herausforderung) kann dezimale E / A für vier zusätzliche Bytes verarbeiten:

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

Probieren Sie es online!

Mit einer unären Eingabe und einer dezimalen Ausgabe können wir 16 Bytes ausführen, aber das scheint ein bisschen lang zu sein:

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

Erläuterung

Immer noch derselbe Ansatz wie bei jedem anderen, aber Regex-Ersetzung für eine unäre Darstellung der Zahl.

11(..?$)?
$_

Dies berechnet n*((n-1)/2) . Wir tun dies, indem wir zwei Zeichen gleichzeitig abgleichen (Division durch zwei) und sie durch die gesamte Zeichenfolge ersetzen (Multiplikation durch n). Das Dekrementieren von nerfolgt durch Überspringen des restlichen Strings, wenn nur noch ein oder zwei Zeichen übrig sind.

11?
1

Dies ist eine ganzzahlige Division durch 2, aufgerundet. Wir ersetzen einfach zwei Zeichen durch eins (Division durch 2), lassen jedoch zu, dass die letzte Übereinstimmung nur aus einem Zeichen besteht (Aufrundung).

Python 3, 39 Bytes

Dies ist ein wenig aufgebläht, aber ich bin nicht sicher, ob ich noch viel weiter Golf spielen könnte. Ein Link zum Testen.

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

Prolog, 39 38 Bytes

Code:

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

Erläuterung:

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.

Beispiel:

p(8).
12

Probieren Sie es hier online aus

Bearbeiten: 1 Byte gespeichert, indem Ceil / 2 durch + 1 // 2 ersetzt wird

Mumps, 17 Bytes

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

Vielen Dank an Emigna für die einfache Erklärung des Algorithmus. Dies nutzt den "Mangel" von Mumps 'Mathematik, dass Operationen ausschließlich von links nach rechts ausgeführt werden (nicht PEMDAS), sodass keine Klammern erforderlich sind. :-)

Die Ausgabe sieht jedoch etwas seltsam aus, da Caches Ensemble (die Mumps-Umgebung, auf die ich Zugriff habe) die Wagenrückläufe nicht automatisch ausgibt, selbst wenn die Eingabetaste gedrückt wird. Wenn es schöner sein soll, fügen Sie 4 Zeichen für die Zeilenumbrüche vor / nach dem Transport hinzu:

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

Vielen Dank!

Bash, 32 Bytes

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

Pyke, 8 Bytes, nicht konkurrierend

Dt2f*h2f

dup, dec, half, mult, inc, half

Probieren Sie es hier aus!

Batch, 30 Bytes

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

38 Bytes, wenn die Eingabe über stdin erforderlich ist:

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