Introdução
Um tabuleiro de damas normal contém 8 x 8 = 64 quadrados:
Você pode ver que, no total, existem 12 peças brancas . Preto e branco sempre têm a mesma quantidade de peças. Se houver mais peças no tabuleiro, as peças serão vizinhas, o que não é permitido para esse desafio. Para esclarecer as coisas, aqui estão alguns exemplos:
O menor quadro possível para esse desafio é 3 x 3 :
Você pode ver que a quantidade máxima de peças é igual a 2 . Portanto, quando dado N = 3 , você precisa gerar 2 . Se a entrada for N = 4 , obtemos o seguinte:
Você pode ver que o valor máximo também é 2. Portanto, para N = 4 , a saída deve ser 2 . Para N = 5 , a saída deve ser igual a 5 :
Exemplos
STDIN: 3
STDOUT: 2
STDIN: 4
STDOUT: 2
STDIN: 5
STDOUT: 5
STDIN: 6
STDOUT: 6
STDIN: 8
STDOUT: 12
Regras
- Sua submissão deve ser um programa, função, etc., que use um número inteiro e produz ou retorna o número de peças no quadro
- Você pode assumir com segurança que a entrada é um número inteiro não negativo> 2
- Isso é código-golfe , então o programa com a menor quantidade de bytes vence!
- Observe que o quadrado no canto inferior esquerdo do quadro está sempre escuro. As peças são colocadas apenas em quadrados escuros
- Você tem que ocupar uma linha cheia de peças
code-golf
game
grid
board-game
Adnan
fonte
fonte
Respostas:
Par , 8 bytes
Um byte é usado por caractere.
Explicação
fonte
Hexagonia , 19 bytes
Experimente online.
Explicação
Esse ainda é o mesmo cálculo que eu usei nas minhas respostas CJam e Labyrinth, mas devido ao modelo de memória ... especial ... do Hexagony, é um pouco mais complicado compactar o cálculo em 19 bytes (para que ele caiba dentro de um hexágono 3 de comprimento lateral).
Como minha resposta do labirinto, isso termina com um erro de divisão por 0.
Aqui está o código desdobrado:
Como eu disse, o código é totalmente linear. Você pode juntar o caminho executado em ordem cinza-roxo-verde-vermelho-azul. O caminho continua um pouco mais até atingir o
:
lado esquerdo. Removendo o/
(que redireciona apenas o fluxo de controle), todo o programa desenrolado linearmente é:Então a questão é como isso funciona. A memória do hexagony é o gráfico de linhas de uma grade hexadecimal, em que cada extremidade da grade contém um valor inteiro (inicialmente zero). O ponteiro de memória (MP) está sempre em uma borda e aponta em uma determinada direção ao longo dessa borda. As operações aritméticas são geralmente aplicadas às duas arestas pontiagudas para e armazenados na borda da MP está ligado.
Para este programa, usaremos as três arestas rotuladas A , B , C , com o MP iniciando como mostrado aqui:
Então, aqui está como isso funciona:
fonte
{
, o IP salta para o2
canto esquerdo. Depois do)
canto direito, o IP salta para o'
canto inferior esquerdo. Em seguida, o IP percorre as linhas 2 e 4 de uma maneira estranha e ciclicamente envolvente.LabVIEW,
2820 Primitivas do LabVIEWfonte
CJam, 10 bytes
Teste aqui.
Explicação
fonte
Labirinto , 11 bytes
Woohoo, apenas um byte atrás do CJam .
Experimente online.
É essencialmente a mesma coisa:
No entanto, neste momento, o programa ainda não termina. Em vez disso, o ponteiro de instruções atingiu um beco sem saída e se vira. Mas agora
/
tenta calcular o0/0
que termina com um erro .fonte
Sério , 8 bytes
Sério tem o útil
½
(flutuar dividir por 2) eK
(teto), portanto, não precisamos adicionar um antes da divisão.Experimente aqui com explicação.
fonte
Python 2,
2221 bytesEu primeiro separo em dois casos, N ímpar e N.
Com N ímpar, podemos preencher (N - 1) / 2 linhas, contendo em média N / 2 peças. Como a primeira linha sempre tem mais peças, devemos limitar esse resultado. Então, quando N é ímpar, temos peças de teto ((N-1) / 2 * N / 2).
Com N uniforme, podemos preencher linhas N / 2 - 1 ou piso ((N - 1) / 2), cada linha contendo N / 2 partes.
Podemos combinar essas duas expressões por teto (piso ((N-1) / 2) * N / 2)). Desde ceil (x / 2) = andar ((x + 1) / 2) podemos usar piso Divisão:
((N - 1) // 2 * N + 1) // 2
.fonte
JavaScript,
3735 bytesExplicação
Usa uma técnica semelhante ao restante das respostas. Este é o algoritmo não destruído:
fonte
dc, 12
Saída de teste:
fonte
Pitão, 9 bytes
O mesmo algoritmo da minha resposta do Python 2.
fonte
Japonês ,
1614 bytesExperimente online!
Como funciona
Bem simples:
Eu gostaria que houvesse alguma maneira de levar em conta que as duas metades do código são muito semelhantes. Sugestões são bem-vindas!
Versão antiga (16 bytes):
fonte
Java,
23015552Golfe:
Ungolfed:
Saída do programa:
fonte
throws Exception
é permitido.Scanner
classe para entrada. Isso economizaria um monte de bytes, eu acho. (ABufferedReader
/InputStreamReader
combinação pode ser melhor no uso geral, mas este é o golfe código, eScanner
funciona muito bem para a entrada simples.)Código da máquina Zilog ez80, 9 bytes
Em hexadecimal:
Na montagem:
A entrada está no registro
h
e a saída está nol
.O Zilog ez80 é um processador de 8 bits com um acumulador de 8 bits e registradores de 24 bits. Diferentemente do z80, ele possui uma
mlt
instrução (multiplicação de 8 bits), que, no modo de 16 bits, multiplica os bytes alto e baixo de um par de registradores aquihl
e armazena novamentehl
.Isso funciona apenas para valores para os quais duas vezes o resultado se encaixa em 8 bits; isto é, n≤23.
fonte
TI-BASIC, 13 bytes
A multiplicação implícita do TI-BASIC ajuda, mas não possui divisão inteira.
⁻int(⁻X
é uma forma mais curta de teto (x).fonte
vba, 46
Ligue com? F (x) ou = f (A1) em uma fórmula
fonte
Pitão,
171413 bytes-3 bytes graças a Ypnypn ! Reorganizou os números do operador * para economizar 1 byte.
Explicação:
Quando n é par, podemos ocupar n / 2-1 linhas com n / 2 partes, perfazendo um total de n * (n / 2-1) / 2 partes. Essa expressão é equivalente a (n * (n / 2-1) +1) / 2
Quando n é ímpar, podemos descobrir como seria o dobro do número de peças, o dobro do número de peças abrangerá n-1 linhas e, se eu retirar uma peça, podemos dividir as n-1 linhas em (n- 1) / 2 grupos de 2 linhas, de modo que cada grupo tenha n partes, portanto a expressão para este caso é (n * (n / 2) +1) / 2
Agora que as duas expressões são bastante semelhantes, podemos escrever o código.
Minha primeira vez usando uma linguagem de golfe.
fonte
Javascript, 33 bytes
Se uma função ES6 for permitida, 18 bytes:
fonte
MATLAB,
3725 bytesEu acredito que isso deve funcionar, funciona para todos os casos de teste.
Também funciona no Octave . Você pode tentar online aqui .
Para o código antigo eu adicionei o programa para a área de trabalho em um arquivo chamado
checkerboard.m
. Você pode executá-lo simplesmente digitandocheckerboard
no prompt e, quando iniciar, digite o tamanho necessário no prompt. O resultado será impresso.Para o novo código, basta inserir o código postado aqui no prompt e chamar a função anônima como
ans(n)
.fonte
Retina , 18 bytes
Entrada e saída são unárias .
Experimente online!
A versão mais recente do Retina (mais recente que esse desafio) pode lidar com E / S decimal por quatro bytes adicionais:
Experimente online!
Com entrada unária e saída decimal, podemos fazer 16 bytes, mas isso parece um pouco exagerado:
Explicação
Ainda é a mesma abordagem que qualquer pessoa, mas usando a substituição de regex em uma representação unária do número.
Isso calcula
n*((n-1)/2)
. Fazemos isso combinando dois caracteres de cada vez (divisão por dois) e substituindo-os pela string inteira (multiplicação porn
). O decréscimo den
é feito ignorando o restante da sequência, se houver apenas um ou dois caracteres.Esta é a divisão inteira por 2, arredondada para cima. Simplesmente substituímos dois caracteres por um (divisão por 2), mas permitimos que a última correspondência consista em apenas um caractere (arredondamento para cima).
fonte
Python 3, 39 bytes
Isso está um pouco inchado, mas não tenho certeza se poderia jogar muito mais longe do que isso. Um link para teste.
fonte
Prolog,
3938 bytesCódigo:
Explicação:
Exemplo:
Experimente online aqui
Editar: salvou 1 byte substituindo ceil / 2 por + 1 // 2
fonte
Caxumba, 17 bytes
Graças a Emigna pela explicação simples do algoritmo. Isso explora a "deficiência" matemática de Mumps de que as operações são executadas estritamente da esquerda para a direita (não do PEMDAS), de modo que os parênteses não são necessários. :-)
A saída parece um pouco estranha, no entanto, como o Ensemble do Cache (o ambiente Mumps ao qual tenho acesso) não gera automaticamente retornos de carro mesmo quando pressionado na entrada. Se você quiser mais bonito, adicione 4 caracteres para retornos de carro pré / pós:
Obrigado!
fonte
Bash, 32 bytes
fonte
Pyke, 8 bytes, não-competitivo
dup, dec, metade, mult, inc, metade
Experimente aqui!
fonte
Lote, 30 bytes
38 bytes se a entrada no stdin for necessária:
fonte