Combien de Wazirs peuvent être placés sur un échiquier N × N?

30

Supposons qu'une nouvelle pièce d'échecs féérique nommée le Wazir soit introduite aux échecs. Les wazirs peuvent passer d'une position ( x , y ) à:
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1)

Autrement dit, ils se déplacent orthogonalement comme la tour, mais seulement un pas à la fois comme le roi. Combien de ces wazirs peuvent être placés sur un échiquier N × N afin qu'aucun deux wazirs ne puissent s'attaquer?

 Sur une planche 1 × 1, il ne peut y avoir qu'une seule pièce de ce type.
 Sur une planche 2 × 2, il peut y avoir 2 pièces de ce type.
 Sur une planche 3 × 3, il peut y avoir 5 pièces de ce type.

Étant donné N, renvoyez le nombre de wazirs pouvant être placés sur un échiquier N × N.

Il s'agit de la séquence OEIS A000982 .

Plus de cas de test

7 → 25

8 → 32

100 → 5000

code-golf  number  chess 
— Sasha R
source
4
Le Chameau est donc pour la Tour ce que le Roi est pour la Reine? C'est à dire ne peut se déplacer que orthogonalement, et seulement un pas à la fois.
— 2017
2
@SashaR Puis-je réécrire votre question comme un défi de golf de code approprié?
— Adám
2
Sûr! De cette façon, je peux également voir comment formuler les questions liées au codage à l'avenir
— Sasha R
15
En tant que nouvel utilisateur de ce site, vous avez eu beaucoup de chance cette fois. De nombreuses questions de programmation (hors sujet) sur ce site ont été définitivement fermées et déclassées, non éditées comme un défi et votées comme celle-ci. Comme d'autres personnes l'ont déjà expliqué, ce site est uniquement destiné à la programmation de concours, pas à des devoirs. Vous pouvez utiliser le bac à sable (à codegolf.meta.stackexchange.com/questions/2140/… ) avant de poster un défi pour éviter les erreurs courantes la prochaine fois; et notez que la plupart des utilisateurs de ce site, comme vous l'avez vu, utilisent des langues "illisibles".
— user202729
16
Cette question est assez déroutante dans la mesure où le chameau est déjà le nom d'échecs de fées standard pour une pièce comme un chevalier qui fait des sauts plus longs et la pièce que vous décrivez a déjà un nom d'échecs de fées: Wazir .
— Mark S.

Réponses:

33

Espace , 45 octets

Essayez-le en ligne!

Au fait, voici une preuve que la formule then² / 2⌉ est correcte.

  • On peut toujours placer au moins ⌉n² / 2⌉ wazirs : il suffit de les disposer en damier! En supposant que la tuile en haut à gauche est blanche, il y a des tuiles blanches ⌈n² / 2⌉ et des tuiles noires ⌊n² / 2⌋ sur le tableau n × n . Et si nous plaçons des wazirs sur les tuiles blanches, il n'y en a pas deux qui s'attaquent, car chaque wazir ne «voit» que des tuiles noires.

    Voici comment nous plaçons 13 wazirs sur une planche 5 × 5 (chaque W est un wazir).

    　　　　　　　　　　13 wazirs sur une planche 5 × 5

  • Nous ne pouvons pas faire mieux : posons arbitrairement le damier avec 2 × 1 pièces de domino, en utilisant éventuellement une pièce de 1 × 1 pour le coin final d'un échiquier de longueur impair, comme ceci:

    　　　　　　　　　　couverture domino d'une planche 5 × 5

    Nous avons besoin de dominos ⌈n² / 2⌉ pour couvrir l'échiquier. De toute évidence, mettre deux wazirs sur un domino permet de s’attaquer! Donc , chaque domino ne peut contenir au plus un vizir, ce qui signifie que nous ne pouvons peut placer plus de ⌈n² / 2⌉ vizirs sur la carte.

— Lynn
source
Vous n'avez pas besoin du principe du pigeonnier pour la dernière partie: vous avez exactement des carreaux ⌈n² / 2⌉, et au plus chameau par carreau, donc vous avez au plus mostn² / 2⌉ chameaux.
— ShreevatsaR
8
@ShreevatsaR Qu'est-ce qui vous assure que vous ne pouvez pas mettre x> ⌈n² / 2⌉ chameaux dans des carreaux ⌈n² / 2⌉? C'est le principe du
— pigeonhole
2
Au début, je pensais que le code ne se chargeait pas, alors j'ai actualisé la page, et ce n'est toujours pas le cas. Ensuite, j'ai réalisé quel nom de langue était écrit en haut.
— Arthur
7
Je comprends que vous êtes allé et ils ont changé votre C« s à W» s dans votre illustration preuve.
— Giuseppe
4
J'apprécie également que les W soient tous sur les ESPACES BLANCS avec une réponse dans WHITESPACE.
— corsiKa
9

APL (Dyalog) , 9 7 6 octets

Utilise maintenant la formule de M. Xcoder.

Il s'agit d'une fonction tacite de préfixe anonyme qui prend N comme argument.

⌈2÷⍨×⍨

Essayez-le en ligne!

×⍨ carré N (lit. multiplication selfie, c.-à-d. multiplier par soi)

2÷⍨ diviser par 2

⌈ plafond (arrondi)

— Adam
source
Wow! Je n'ai aucune idée de comment tu as fait ça !! Je n'ai pas eu la logique en soupirant
— Sasha R
Bon sang, quelqu'un a déjà découvert le motif.
— Feathercrown
1
Huh, vient de réaliser que la formule est sur la page OEIS. N'aurait probablement pas dû lier cela.
— Feathercrown
6

dc , 6 octets

2^2~+p

2^: carré; 2~: divisez par 2 en poussant le quotient puis le reste; +p: ajouter le reste au quotient et imprimer.

Essayez-le en ligne!

— brhfl
source
5

C (gcc) , 23 18 17 octets

  • Sauvegardé un octet grâce à Tahg ; jouer n/2+n%2au golf n+1>>1.
f(n){n=n*n+1>>1;}

Essayez-le en ligne!

C (gcc) , 22 octets (n'utilisant pas de comportement non défini)

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

Essayez-le en ligne!

Certaines personnes n'aiment vraiment pas exploiter le comportement indéfini d'un certain compilateur lors de l'utilisation d'indicateurs de compilateur spécifiques. Cependant, cela permet d'économiser des octets.

— Jonathan Frech
source
3
Façon étrange de fournir une réponse OMI, mais: f (n) {n = n * n + 1 >> 1;} pour enregistrer un octet.
— Tahg
1
@Tahg Merci; mais de quelle manière trouvez-vous étrange ma façon de fournir une réponse?
— Jonathan Frech
2
Je ne pensais pas que changer l'argument d'entrée était un moyen normal de retourner une valeur en C.
— Tahg
2
@YSC Pourtant, de l'avis du compilateur, il est compréhensible et crée un exécutable qui fonctionne.
— Jonathan Frech
5
@YSC Nous croyons ici sur PPCG que, si le programme fonctionne avec un seul interprète, c'est une soumission valide. Il fonctionne sur un interprète en ligne, il est donc valable sans autre remarque.
— Conor O'Brien
4

Python 3 , 19 octets

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

Essayez-le en ligne!

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 octet merci à M. Xcoder

— HyperNeutrino
source
x**2->x*x
— M. Xcoder du
@ Mr.Xcoder Facepalm merci
— HyperNeutrino
Et alors lambda x:x*x+1>>1?
— Alix Eisenhardt
Ou lambda x:x*x+1//2 Disclaimer: Je ne connais pas la syntaxe ou l'ordre des opérations de ce langage, donc j'ai deviné; Je dis ajouter 1 devant vous //2 au lieu de nier deux fois.
— Dan Henderson
@DanHenderson Vous avez toujours besoin de parenthèses, sinon il est analysé comme (x*x) + (1//2), donc ce n'est pas réellement plus court.
— Skyler
4

langage machine x86_64 (Linux), 9 8 octets

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

Pour l' essayer en ligne! , compilez et exécutez le programme C suivant.

#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));
  }
}
— plafond
source
3

J , 8 octets

Fonction de préfixe tacite anonyme.

2>.@%~*:

Essayez-le en ligne!

*: carré

>. plafond (arrondi)
@ après
2… %~ division par deux

— Adam
source
Solutions alternatives: <.@-:@*:et*:<.@%2:
— Conor O'Brien
2
@ ConorO'Brien‽ 2>.@%~*:D'où ai-je obtenu cela? Je ne peux pas lire ça - ça ressemble à du bruit de ligne pour moi…
— Adám
>.@-:@*:obtient mon vote.
— Jonah
1
@Jonah Si vous plissez les yeux, vous pouvez voir un chameau.
— 2017
3

R , 22 21 octets

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

Essayez-le en ligne!

Carré, incrément, division entière. Peasy facile.

Entrée de stdin; il peut prendre de l'espace ou une entrée séparée par une nouvelle ligne et il calculera le nombre maximal de wazirs pour chaque taille de carte d'entrée. Sortie vers sortie standard.

-1 octet grâce à plannapus

— Giuseppe
source
@plannapus fixe, merci.
— Giuseppe
2

Cubix , 11 octets

Iu*:^\)2,O@

Heheh, :^\)

Essayez-le en ligne!

Se développe dans le cube suivant:

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

C'est le même algorithme que beaucoup utilisent.

  • ^Iu : lire l'entrée en tant qu'int et changer de direction
  • :* : copier le haut de la pile, multiplier
  • \) : changer de direction, incrémenter
  • 2, : push 2, division entière
  • O@ : imprimer la sortie en int, terminer le programme.
— Giuseppe
source
1

Japt , 4 octets

Je suis assis dessus depuis la fin du défi.

²Ä z

Essayez-le

Explication: carré, ajouter 1, division du sol par 2

Alternative

²ÄÁ1

Essayez-le

Explication: carré, ajoutez 1, décalage de bit à droite de 1.

— Hirsute
source
1

Commentateur , 19 octets

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

Essayez-le en ligne!

Qui a besoin de langues de golf? J'ai des langues déroutantes!

Version non golfée:

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

Essayez-le en ligne!

Comment ça marche? Je vais vous expliquer, avec l'entrée 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
source
1

OCaml , 19 octets

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

Essayez-le en ligne!

Je suis un peu déçu que le nom soit passé de "chameaux" à "wazirs" avant d'avoir réussi à écrire ceci, mais j'ai pensé que je le publierais quand même.

— Giuseppe
source
1

TI-Basic, 7 octets

round(Ans²/2,0

Alternativement (8 octets):

int(Ans²/2+.5
— Timtech
source
-int(-.5Ans²fonctionne également
— Oki
@Oki C'est sûr. Je souhaite juste qu'ils aient une ceil(fonction.
— Timtech
1

/// , 35 octets

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

Essayez-le en ligne!

Prend l'entrée dans le symbole unaire à l'aide *et la sortie dans le symbole unaire à l'aide A. Ceci est autorisé pour certaines langues spécifiques, notamment /// ( méta )

Parce qu'il n'y a aucun moyen de prendre des entrées dans ///, les entrées doivent être codées en dur:

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

pour entrée = 4.

Explication: (avant de lire, vous devez savoir que la seule syntaxe de ///are /pattern/replacement/, qui remplace chaque occurrence de patternby replacement; et \pour l'échappement; d'autres caractères sont imprimés pour sortir)

Pour 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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.