Quantos Wazirs podem ser colocados em um tabuleiro de xadrez N × N?

30

Suponha que uma nova peça de xadrez de fadas chamada Wazir seja introduzida no xadrez. Os wazirs podem se mover de uma posição ( x , y ) para:
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1)

Ou seja, eles se movem ortogonalmente como a torre, mas apenas um passo de cada vez como o rei. Quantos wazirs podem ser colocados em um tabuleiro de xadrez N × N para que dois wazirs não possam se atacar?

 Em uma placa 1 × 1, pode haver apenas 1 peça.
 Em uma placa 2 × 2, pode haver 2 dessas peças.
 Em uma placa 3 × 3, pode haver 5 dessas peças.

Dado N, retorne o número de wazirs que podem ser colocados em um tabuleiro de xadrez N × N.

Esta é a seqüência OEIS A000982 .

Mais casos de teste

7 → 25

8 → 32

100 → 5000

code-golf  number  chess 
— Sasha R
fonte
4
Então o camelo é para a torre o que o rei é para a rainha? Ou seja, só pode se mover ortogonalmente e apenas um passo de cada vez.
— Adám
2
@SashaR Posso reescrever sua pergunta como um desafio de golfe com código adequado?
— Adám
2
Certo! Dessa forma, eu também pode ver como a palavra codificação relacionados com questões no futuro
— Sasha R
15
Como novo usuário deste site, desta vez você teve muita sorte. Muitas questões de programação (fora do tópico) deste site foram permanentemente encerradas e com voto negativo, não editadas como um desafio e votadas como esta. Como outras pessoas já explicaram, este site é apenas para programar competições, não para pedir trabalhos de casa. Você pode usar a sandbox (em codegolf.meta.stackexchange.com/questions/2140/… ) antes de postar um desafio para evitar erros comuns na próxima vez; e observe que a maioria dos usuários deste site, como você viu, usa idiomas "ilegíveis".
— user202729
16
Essa pergunta é bastante confusa, pois o Camel já é o nome padrão do xadrez de fadas para uma peça como um cavaleiro que faz saltos mais longos e a peça que você descreve já tem um nome de xadrez de fadas: Wazir .
— Mark S.

Respostas:

33

Espaço em branco , 45 bytes

Experimente online!

A propósito, aqui está uma prova de que a fórmula ⌈n² / 2⌉ está correta.

  • Sempre podemos colocar pelo menos ⌈n² / 2⌉ wazirs : basta colocá-los em um padrão quadriculado! Supondo que o bloco superior esquerdo seja branco, existem ladrilhos ²n² / 2 / e ladrilhos ⌋n² / 2⌋ pretos na placa n × n . E se colocarmos wazirs nos ladrilhos brancos, nenhum deles estará se atacando, pois todo wazir apenas "vê" ladrilhos pretos.

    Veja como colocamos 13 wazirs em um tabuleiro 5 × 5 (cada W é um wazir).

    　　　　　　　　　　13 wazirs em uma placa 5 × 5

  • Não podemos fazer melhor : vamos arbitrariamente ladrilhar arbitrariamente o tabuleiro de xadrez com peças de dominó 2 × 1, usando opcionalmente uma peça 1 × 1 para o canto final de um tabuleiro de xadrez de comprimento ímpar, da seguinte forma:

    　　　　　　　　　　capa de dominó de uma placa 5 × 5

    Precisamos de dominós ⌈n² / 2⌉ para cobrir o tabuleiro de xadrez. Claramente, colocar duas wazirs em um dominó faz com que elas possam se atacar! Assim, cada dominó só pode conter no máximo um vizir, o que significa que não pode , possivelmente, colocar mais de ⌈n² / 2⌉ wazirs no tabuleiro.

— Lynn
fonte
Você não precisa do princípio do buraco de pombo para a última parte: possui exatamente ladrilhos de ²n² / 2⌉ e, no máximo, camelo por ladrilho, portanto, possui no máximo camelos de ²n² / 2⌉.
— ShreevatsaR
8
@ShreevatsaR O que garante que você não pode colocar x> ²n² / 2⌉ camelos em ladrilhos ⌈n² / 2⌉? É o princípio da casa dos pombos ...
— frarugi87
2
Inicialmente, pensei que o código não carregava, por isso atualizei a página e ainda não o fez. Então eu percebi o nome do idioma escrito no topo.
— Arthur
7
Aprecio que você foi e mudou seu Cpara Wna sua ilustração de prova.
— 21417 Giuseppe
4
Eu também aprecio que os Ws estejam todos no WHITE SPACES com uma resposta no WHITESPACE.
— CorsiKa 4/17
9

APL (Dyalog) , 9 7 6 bytes

Agora usa a fórmula do Sr. Xcoder.

Esta é uma função tácita de prefixo anônimo que aceita N como argumento.

⌈2÷⍨×⍨

Experimente online!

×⍨ quadrado N (lit. multiplicação selfie, isto é, multiplicar por si mesmo)

2÷⍨ dividir por 2

⌈ teto (arredondado para cima)

— Adão
fonte
Uau! Eu não tenho nenhuma idéia de como você fez isso !! Será que não recebem a lógica embora suspiro
— Sasha R
Droga, alguém já descobriu o padrão.
— Feathercrown
1
Ah, acabei de perceber que a fórmula está na página da OEIS. Provavelmente não deveria ter ligado isso.
— Feathercrown
6

dc , 6 bytes

2^2~+p

2^: quadrado; 2~: divida por 2, pressionando o quociente e depois o restante; +p: adicione o restante ao quociente e imprima.

Experimente online!

— brhfl
fonte
5

C (gcc) , 23 18 17 bytes

  • Guardou um byte graças a Tahg ; golfe n/2+n%2para n+1>>1.
f(n){n=n*n+1>>1;}

Experimente online!

C (gcc) , 22 bytes (sem usar comportamento indefinido)

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

Experimente online!

Algumas pessoas realmente não gostam de explorar o comportamento indefinido de um determinado compilador ao usar sinalizadores de compilador específicos. Fazer isso salva os bytes, no entanto.

— Jonathan Frech
fonte
3
Maneira estranha de fornecer uma resposta IMO, mas: f (n) {n = n * n + 1 >> 1;} para salvar um byte.
— Tahg
1
@Tahg Thanks; embora, de que maneira você acha estranha a minha maneira de fornecer uma resposta?
— Jonathan Frech
2
Eu não acho que mudar o argumento de entrada foi uma forma normal de retornar um valor em C.
— Tahg
2
@YSC No entanto, na opinião do compilador, é compreensível e cria um executável que funciona.
— Jonathan Frech
5
@YSC Acreditamos aqui no PPCG que, se o programa funcionar em um intérprete, é um envio válido. Funciona em um intérprete on-line; portanto, é válido sem outras observações.
— Conor O'Brien
4

Python 3 , 19 bytes

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

Experimente 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 graças ao Sr. Xcoder

— HyperNeutrino
fonte
x**2->x*x
— Sr. Xcoder
@ Mr.Xcoder Facepalm obrigado
— HyperNeutrino 2/17/17
Que tal lambda x:x*x+1>>1?
— Alix Eisenhardt
Ou lambda x:x*x+1//2 Isenção de responsabilidade: não conheço a sintaxe ou a ordem de operações desse idioma, então imaginei; Estou dizendo adicionar 1 antes de você em //2 vez de negar duas vezes.
— Dan Henderson
@ DanHenderson Você ainda precisa de parênteses, caso contrário é analisado como (x*x) + (1//2), de modo que não é realmente mais curto.
— Skyler
4

linguagem de máquina x86_64 (Linux), 9 8 bytes

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

Para experimentá-lo online! , compile e execute o seguinte programa 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));
  }
}
— teto
fonte
3

J , 8 bytes

Função de prefixo tácito anônimo.

2>.@%~*:

Experimente online!

*: quadrado

>. teto (arredondado para cima)
@ depois de
2… %~ dividir por dois

— Adão
fonte
Soluções alternativas: <.@-:@*:e*:<.@%2:
— Conor O'Brien
2
@ ConorO'Brien‽ 2>.@%~*:De onde eu tirei isso? Não consigo ler isso - parece barulho de linha para mim ...
— Adám 03/10/19
>.@-:@*:recebe meu voto.
— Jonah
1
@ Jonah Se você apertar os olhos, pode ver um camelo.
— Adám
3

R , 22 21 bytes

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

Experimente online!

Quadrado, incremento, divisão de número inteiro. Mole-mole.

Entrada de stdin; pode levar espaço ou entrada separada por nova linha e calculará o máximo de wazirs para cada tamanho de placa de entrada. Saída para stdout.

-1 byte graças ao plannapus

— Giuseppe
fonte
@ plannapus corrigido, obrigado.
— 11557 Giuseppe
2

Cubix , 11 bytes

Iu*:^\)2,O@

Heheh, :^\)

Experimente online!

Expande para o seguinte cubo:

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

Qual é o mesmo algoritmo que muitos usam.

  • ^Iu : ler na entrada como int e alterar as direções
  • :* : duplicar o topo da pilha, multiplicar
  • \) : mudar de direção, incrementar
  • 2, : push 2, divisão de número inteiro
  • O@ : imprime a saída como int, finaliza o programa.
— Giuseppe
fonte
1

Japonês , 4 bytes

Estive sentado neles desde que o desafio foi encerrado.

²Ä z

Tente

Explicação: Quadrado, adicione 1, divida no piso por 2

Alternativo

²ÄÁ1

Tente

Explicação: Quadrado, adicione 1, desloque o bit à direita por 1.

— Shaggy
fonte
1

Comentador , 19 bytes

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

Experimente online!

Quem precisa de idiomas de golfe? Eu tenho idiomas confusos!

Versão não destruída:

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

Experimente online!

Como funciona? Vou explicar, com a entrada 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 bytes

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

Experimente online!

Estou um pouco chateado porque o nome mudou de "camelos" para "wazirs" antes que eu conseguisse escrever isso, mas achei que iria postá-lo de qualquer maneira.

— Giuseppe
fonte
1

TI-Basic, 7 bytes

round(Ans²/2,0

Como alternativa (8 bytes):

int(Ans²/2+.5
— Timtech
fonte
-int(-.5Ans²também funciona
— Oki
@Oki Com certeza. Eu só queria que eles tivessem uma ceil(função.
— Timtech 5/17
1

/// , 35 bytes

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

Experimente online!

Leva a entrada em unário usando o símbolo *e a saída em unário usando o símbolo A. Isso é permitido para alguns idiomas específicos, incluindo /// ( meta )

Como não há como receber entrada em ///, a entrada deve ser codificada permanentemente:

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

para entrada = 4.

Explicação: (antes de ler, você precisa saber que a única sintaxe de ///é /pattern/replacement/, que substitui todas as ocorrências de patternby replacement; e \para escape; outros caracteres são impressos na saída)

Para 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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.