Quanti Wazir possono essere posizionati su una scacchiera N × N?

30

Supponiamo che un nuovo pezzo degli scacchi delle fate chiamato Wazir venga introdotto negli scacchi. I Wazir possono spostarsi da una posizione ( x , y ) a:
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1)

Cioè, si muovono ortogonalmente come la torre, ma solo un passo alla volta come il re. Quanti di questi wazir possono essere posizionati su una scacchiera N × N in modo che due wazir non possano attaccarsi a vicenda?

 Su una tavola 1 × 1, può esserci solo 1 pezzo del genere.
 Su una tavola 2 × 2, ci possono essere 2 di questi pezzi.
 Su una tavola 3 × 3, ci possono essere 5 di questi pezzi.

Dato N, restituisce il numero di wazir che possono essere posizionati su una scacchiera N × N.

Questa è la sequenza OEIS A000982 .

Altri casi di test

7 → 25

8 → 32

100 → 5000

code-golf  number  chess 
— Sasha R
fonte
4
Quindi il cammello è per il corvo ciò che il re è per la regina? Cioè può muoversi solo ortogonalmente e solo un passo alla volta.
— Adám,
2
@SashaR Posso riscrivere la tua domanda come una vera e propria sfida di golf nel codice?
— Adám,
2
Sicuro! In questo modo posso anche vedere come scrivere domande relative al codice in futuro
— Sasha R
15
Come nuovo utente di questo sito, questa volta sei stato molto fortunato. Molte domande di programmazione (fuori tema) su questo sito sono state definitivamente chiuse e ridimensionate, non modificate come una sfida e votate come questa. Come altre persone hanno già spiegato, questo sito è solo per le gare di programmazione, non per fare i compiti. Puoi usare la sandbox (su codegolf.meta.stackexchange.com/questions/2140/… ) prima di pubblicare una sfida per evitare errori comuni la prossima volta; e nota che la maggior parte degli utenti di questo sito, come hai visto, usano lingue "illeggibili".
— user202729
16
Questa domanda è piuttosto confusa in quanto il Camel è già il nome standard degli scacchi delle fate per un pezzo come un cavaliere che fa salti più lunghi e il pezzo che descrivi ha già un nome degli scacchi delle fate: Wazir .
— Marco

Risposte:

33

Spazio bianco , 45 byte

Provalo online!

A proposito, ecco una prova che la formula ⌈n² / 2⌉ è corretta.

  • Possiamo sempre posizionare almeno azn² / 2⌉ wazir : basta disporli in uno schema a scacchiera! Supponendo che la tessera in alto a sinistra sia bianca, ci sono piastrelle bianche ⌈n² / 2⌉ e piastrelle nere ⌊n² / 2⌋ sulla scheda n × n . E se posizioniamo i wazir sulle piastrelle bianche, nessuno di loro si attacca a vicenda, poiché ogni wazir "vede" solo piastrelle nere.

    Ecco come posizioniamo 13 wazir su una tavola 5 × 5 (ogni W è un wazir).

    　　　　　　　　　　13 wazir su una tavola 5 × 5

  • Non possiamo fare di meglio : piastrelliamo arbitrariamente la scacchiera con pezzi di domino 2 × 1, opzionalmente usando un pezzo di 1 × 1 per l'angolo finale di una scacchiera di lunghezza dispari, in questo modo:

    　　　　　　　　　　copertina domino di una tavola 5 × 5

    Abbiamo bisogno di domino ²n² / 2⌉ per coprire la scacchiera. Chiaramente, mettere due wazir su un domino fa sì che possano attaccarsi a vicenda! Quindi ogni domino può contenere al massimo un solo wazir, il che significa che non possiamo collocare più di azn² / 2⌉ wazir sul tabellone.

— Lynn
fonte
Non è necessario il principio del buco del piccione per l'ultima parte: hai esattamente ⌈n² / 2⌉ tessere e al massimo cammello per tessera, quindi hai al massimo ⌈n² / 2⌉ cammelli.
— ShreevatsaR,
8
@ShreevatsaR Cosa ti assicura che non puoi mettere x> ²n² / 2⌉ cammelli in ⌈n² / 2⌉ tessere? È il principio del
— buco del piccione
2
All'inizio ho pensato che il codice non si caricasse, quindi ho aggiornato la pagina e ancora non lo ha fatto. Poi ho capito quale nome della lingua era scritto in alto.
— Arthur,
7
Apprezzo che tu sia andato e abbia cambiato i tuoi Cin quelli Wnella tua illustrazione di prova.
— Giuseppe,
4
Apprezzo anche che i W siano tutti sugli SPAZI BIANCHI con una risposta in WHITESPACE.
— corsiKa
9

APL (Dyalog) , 9 7 6 byte

Ora usa la formula di Mr. Xcoder.

Questa è una funzione tacita con prefisso anonimo che accetta N come argomento.

⌈2÷⍨×⍨

Provalo online!

×⍨ quadrato N (lett. selfie moltiplicazione, ovvero moltiplicare per sé)

2÷⍨ dividere per 2

⌈ soffitto (arrotondato per eccesso)

— Adamo
fonte
Wow! Non ho idea di come tu abbia fatto questo! Non ho capito la logica anche se sospiro
— Sasha R
Accidenti, qualcuno ha già scoperto il modello.
— Feathercrown
1
Eh, ho appena realizzato che la formula è sulla pagina OEIS. Probabilmente non avrei dovuto collegarlo.
— Feathercrown
6

dc , 6 byte

2^2~+p

2^: piazza; 2~: dividere per 2, spingendo il quoziente e poi il resto; +p: aggiungi il resto al quoziente e stampa.

Provalo online!

— brhfl
fonte
5

C (gcc) , 23 18 17 byte

f(n){n=n*n+1>>1;}

Provalo online!

C (gcc) , 22 byte (non utilizzando un comportamento indefinito)

f(n){return n*n+1>>1;}

Provalo online!

Ad alcune persone non piace davvero sfruttare il comportamento indefinito di un determinato compilatore quando si usano flag di compilatore specifici. In questo modo, però, si risparmiano byte.

— Jonathan Frech
fonte
3
Strano modo di fornire una risposta IMO, ma: f (n) {n = n * n + 1 >> 1;} per salvare un byte.
— Tahg,
1
@ Grazie Grazie; sebbene in che modo trovi strano il mio modo di fornire una risposta?
— Jonathan Frech,
2
Non pensavo che cambiare l'argomento di input fosse un modo normale per restituire un valore in C.
— Tahg,
2
@YSC Tuttavia, secondo il compilatore, è comprensibile e crea un eseguibile che funziona.
— Jonathan Frech,
5
@YSC Riteniamo qui su PPCG che, se il programma funziona su un interprete, è una proposta valida. Funziona su un interprete online, è quindi valido senza ulteriori osservazioni.
— Conor O'Brien,
4

Python 3 , 19 byte

lambda x:-(-x*x//2)

Provalo online!

lambda x:-(-x*x//2)  # Unnamed function
lambda x:            # Given input x:
            x*x      # Square
           -         # Negate
               //2   # Halve and Floor (equivalent of Ceil)
         -(       )  # Negate again (floor -> ceil)

-1 byte grazie a Mr. Xcoder

— HyperNeutrino
fonte
x**2->x*x
— Mr. Xcoder,
@ Mr.Xcoder Facepalm grazie
— HyperNeutrino
Che dire lambda x:x*x+1>>1?
— Alix Eisenhardt,
O lambda x:x*x+1//2 disclaimer: non conosco la sintassi o l'ordine delle operazioni di questa lingua, quindi ho indovinato; Sto dicendo aggiungi 1 prima di te //2 invece di negare due volte.
— Dan Henderson,
@DanHenderson Hai ancora bisogno di parentesi, altrimenti viene analizzato come (x*x) + (1//2), quindi non è in realtà più breve.
— Skyler,
4

linguaggio macchina x86_64 (Linux), 9 8 byte

0:       97                      xchg   %eax,%edi
1:       f7 e8                   imul   %eax
3:       ff c0                   inc    %eax
5:       d1 f8                   sar    %eax
7:       c3                      retq

Per provarlo online! , compilare ed eseguire il seguente programma C.

#include<stdio.h>
const char *f="\x97\xf7\xe8\xff\xc0\xd1\xf8\xc3";
int main() {
  for(int i=1; i<10; i++) {
    printf("%d\n", ((int(*)())f)(i));
  }
}
— ceilingcat
fonte
3

J , 8 byte

Funzione prefisso tacito anonimo.

2>.@%~*:

Provalo online!

*: piazza

>. soffitto (arrotondato per eccesso)
@ dopo
2... %~ dividendo per due

— Adamo
fonte
Soluzioni alternative: <.@-:@*:e*:<.@%2:
— Conor O'Brien,
2
@ ConorO'Brien‽ 2>.@%~*:Da dove l'ho preso? Non riesco a leggerlo - mi sembra un rumore di linea ...
— Adám,
>.@-:@*:ottiene il mio voto.
— Giona
1
@Giona Se socchiudi gli occhi, puoi vedere un cammello.
— Adám,
3

R , 22 21 byte

cat((scan()^2+1)%/%2)

Provalo online!

Quadrato, incremento, divisione intera. Vai tranquillo.

Input da stdin; può richiedere spazio o input separato da newline e calcolerà il numero massimo di wazir per ciascuna dimensione di input board. Uscita su stdout.

-1 byte grazie a plannapus

— Giuseppe
fonte
@plannapus risolto, grazie.
— Giuseppe,
2

Cubix , 11 byte

Iu*:^\)2,O@

heheh, :^\)

Provalo online!

Si espande nel cubo seguente:

    I u
    * :
^ \ ) 2 , O @ .
. . . . . . . .
    . .
    . .

Qual è lo stesso algoritmo che molti usano.

  • ^Iu : leggi in input come int e cambia direzione
  • :* : dup top dello stack, moltiplicare
  • \) : cambia direzione, incrementa
  • 2, : push 2, divisione intera
  • O@ : stampa l'output come int, termina il programma.
— Giuseppe
fonte
1

Japt , 4 byte

Sono stato seduto su questi da quando la sfida è stata chiusa.

²Ä z

Provalo

Spiegazione: Quadrato, aggiungi 1, divisione del pavimento per 2

Alternativa

²ÄÁ1

Provalo

Spiegazione: Quadrato, aggiungi 1, bit-shift a destra di 1.

— ispido
fonte
1

Commentatore , 19 byte

//{-//-}! {-#  -}<!

Provalo online!

Chi ha bisogno delle lingue del golf? Ho lingue confuse!

Versione non golfata:

5//{-8}//{5-}
print(10!= 5)
x={-1,3,4} # Smiley :-}
print(5<!=10)*/ # Weird comparision.

Provalo online!

Come funziona? Spiegherò, con input 5

//                         - Take input.                           Tape: [5 0 0]
  {-//-}!                  - Square the input.                     Tape: [25 0 0]
  {-                         - Move one along the tape
    //                       - Copy the input to the tape.         Tape: [5 5 0]
      -}                     - Move one back along the tape
        !                    - Take the product of the tape.       Tape: [25 5 0]
         <space>           - Increment the tape head.              Tape: [26 5 0]
                 {-#  -}<! - Halve the tape head (floor division). Tape: [13 2 0]
                 {-          - Move one along the tape
                   #         - Set the tape head to 2.             Tape: [26 2 0]
                      -}     - Move one back along the tape
                        <!   - Reduce the tape by floor division.  Tape: [13 2 0]
— caird coinheringaahing
fonte
1

OCaml , 19 byte

let f n=(n*n+1)/2;;

Provalo online!

Sono un po 'sconvolto, il nome è stato cambiato da "cammelli" a "wazir" prima di riuscire a scrivere questo, ma ho pensato di pubblicarlo comunque.

— Giuseppe
fonte
1

TI-Basic, 7 byte

round(Ans²/2,0

In alternativa (8 byte):

int(Ans²/2+.5
— Timtech
fonte
-int(-.5Ans²funziona anche
— Oki il
@Oki Lo fa sicuramente. Vorrei solo che avessero una ceil(funzione.
— Timtech,
1

/// , 35 byte

/I///,*/+,//+/I//**,/,A//*/A//,//,I

Provalo online!

Riceve input in unario usando il simbolo *e output in unario usando il simbolo A. Questo è consentito per alcune lingue specifiche, tra cui /// ( meta )

Poiché non è possibile prendere l'input in ///, l'input deve essere hardcoded:

/I/«put input here»//,*/+,//+/I//**,/,A//*/A//,//,I

per input = 4.

Spiegazione: (prima di leggere, è necessario sapere che l'unica sintassi di ///sono /pattern/replacement/, che sostituisce ogni ricorrenza di patternda replacement; e \per la fuga; altri caratteri vengono stampati in uscita)

Per n=4:

/I/****//,*/+,//+/I//**,/,A//*/A//,//,I    Start program.
/I/****/                                   Replace all `I` in the program by the input.

/,*/+,//+/****//**,/,A//*/A//,//,****      Remaining part of the program.
/,*/+,/                                    Use the `,` as a scanner, scan through `*` after it and convert to `+`.
       /+/****//**,/,A//*/A//,//++++,      Note that only `*` in the second group is affected.
       /+/****/                            Replace all `+` (which is just created) by `n` asterisks (from the first `I` group)

/**,/,A//*/A//,//****************,         Now at the last of the program before the `,` there are `n²` asterisks.
/**,/,A/                                   Scan the `,` to the left to perform division by 2:
                                           replace each `**` by a `A` as the scanner `,` pass through.
/*/A//,//,AAAAAAAA                         Remaining program.
/*/A/                                      If there is any `*` remaining (if `n²` is odd), replace it with `A`.
     /,//                                  Remove the scanner `,`.
          AAAAAAAA                         Output the result.
— user202729
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.