Stückzahl auf einem Schachbrett

14

Einführung

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

Bildbeschreibung hier eingeben

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 :

Bildbeschreibung hier eingeben

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:

Bildbeschreibung hier eingeben

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 :

Bildbeschreibung hier eingeben

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 , 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
Adnan
quelle
3
Warum die Beschränkung auf Vollprogramme und STDIN / STDOUT? IMO ist einfach unfair gegenüber Sprachen, die über den erforderlichen Programm- und / oder Eingabeaufwand verfügen.
Lirtosiast
@ ThomasKwa, du hast recht. Funktionen etc. sind jetzt erlaubt
Adnan

Antworten:

5

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
Ypnypn
quelle
12

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:

Bildbeschreibung hier eingeben

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:

Bildbeschreibung hier eingeben

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.
Martin Ender
quelle
{{verschiebt den Speicherrand zweimal, so dass das & in der zweiten Zeile nichts zu tun scheint? Beide Nachbarn sollten dort 0 sein
Eumel
@Eumel Das ist nicht die Reihenfolge, in der der Code ausgeführt wird. Nach dem ersten {springt die IP 2in die linke Ecke. Nach dem )in der rechten Ecke springt die IP 'in die linke untere Ecke. Dann durchquert die IP die Zeilen 2 und 4 auf seltsame Weise zyklisch.
Martin Ender
oh ich dachte es hat nur das ME geändert, nicht die IP. auch +1 nur für die Verwendung von Hexagonie diese Sprache ist einfach zu lustig
Eumel
@Eumel Das tut es. So werden die Kanten des Codes in Hexagony umbrochen.
Martin Ender
8

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.
Martin Ender
quelle
8

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 .

Martin Ender
quelle
5

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.

Lirtosiast
quelle
5

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.

orlp
quelle
3

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);
user81655
quelle
3

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
$ 
Digitales Trauma
quelle
3

Pyth, 9 Bytes

/h*/tQ2Q2

Gleicher Algorithmus wie meine Python 2-Antwort.

orlp
quelle
3

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
ETHproductions
quelle
3

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

quelle
throws Exceptionist zulässig.
Neil
1
OP erlaubte Funktionen.
Lirtosiast
Sie können die ScannerKlasse für die Eingabe verwenden. Das würde dir ein paar Bytes sparen, denke ich. (Die BufferedReader/ InputStreamReaderCombo ist im allgemeinen Sprachgebrauch vielleicht besser, aber dies ist Codegolf und eignet sich Scannergut für einfache Eingaben.)
Darrel Hoffman
Die Konvertierung in eine eigenständige Funktion und die Verwendung von Parametern / Rückgabewerten anstelle von Standardeingaben / -ausgaben haben einen großen Unterschied gemacht.
2

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.

Lirtosiast
quelle
2

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

Lirtosiast
quelle
2

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

SeanC
quelle
2

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.

Element118
quelle
2

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
Neil
quelle
2

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

Tom Carpenter
quelle
Danke für die Upvotes, endlich 1000 Rep erreicht :) Woop.
Tom Carpenter
@ ThomasKwa danke für den Hinweis. 12 Bytes gespeichert :).
Tom Carpenter
2

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

Martin Ender
quelle
Herzlichen Glückwunsch zu Ihrer 1000. Antwort: p
Adnan
1

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)
Sherlock9
quelle
1

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

Emigna
quelle
1

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!

Zmerch
quelle
1

Bash, 32 Bytes

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

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
Neil
quelle