Você deseja criar um tabuleiro de xadrez quadrado. Os ladrilhos adjacentes devem alternar preto e branco como um tabuleiro de xadrez padrão, e o canto inferior esquerdo pode ser preto ou branco.

Seu programa terá dois números inteiros positivos, o número de preto e o número de ladrilhos brancos. Eles sempre serão menores que 1024. Você não precisa usar todos os blocos.

Saída do comprimento lateral máximo de um padrão de tabuleiro de xadrez que pode ser construído usando a quantidade fornecida de peças.

Casos de teste:

12, 15 -> 5
8, 8 -> 4    
4, 0 -> 1

JavaScript (ES7), 30 bytes

b=>w=>((b<w?b:w)*2|b!=w)**.5|0

Experimente online!

Dado o número de quadrados pretos $b$ o número de quadrados brancos $w$ , isso calcula:

Porque até tamanhos $s$ , precisamos $s^2/2$ quadrados de cada tipo (por exemplo, para $s=8$ : $32$ quadrados pretos e $32$ quadrados brancos).

Por estranho tamanhos $s$ , precisamos $\lfloor s^2/2\rfloor$ quadrados de um tipo e $\lceil s^2/2\rceil$ quadrados de outro tipo (por exemplo, para $s=5$ : $12$ quadrados pretos e $13$ quadrados brancos, ou o inverso) . O parâmetro $k$ é definido como $1$ se $max(b,w)\geq min(b,w)+1$, que representa esse quadrado extra de um lado.

Gelatina , 6 bytes

«Ḥ+nƽ

Experimente online!

Um link diádico que retorna o tamanho máximo da placa.

Conjunto de testes para todas as permutações de números até 20

Explicação

«      | Minimum
 Ḥ     | Doubled
  +n   | Plus 1 if inputs not equal
    ƽ | Integer square root

A resposta de Arnauld tem uma boa explicação para por que isso funciona; por favor, considere votá-lo também!

Haskell , 35 bytes

x#y=floor$sqrt$min(x+y)$1+2*min x y

Experimente online!

Explicação

Esta resposta calcula a seguinte fórmula:

Por que essa fórmula funciona? Bem, vamos começar observando o seguinte:

Cada quadrado de comprimento lateral uniforme pode ser revestido por ladrilhos $2\times 1$ .

e

Cada quadrado de comprimento ímpar pode ser telhado, sobressalente um único $1\times 1$ quadrado, por $2\times 1$ telhas.

Agora, observamos que, se colocarmos esses ladrilhos $2\times 1$ em um tabuleiro de xadrez, cada um ficaria no topo de um quadrado preto e no quadrado branco. Portanto, se fizermos um tabuleiro de xadrez uniforme, cada ladrilho precisa ter um par da outra cor, e se fizermos um tabuleiro de xadrez ímpar para cada ladrilho, mas um precisará de um par da outra cor. Isso nos diz que a resposta nunca é superior a $\left\lfloor\sqrt{2\min(a,b)+1}\right\rfloor$. $2\min(a,b)$é o número máximo de pares que podemos fazer e a$+1$ é a última quadrado que does not' precisa de um par. O problema é que, se$a=b$ , não teremos o quadrado extra para o caso ímpar. Então, adicionamos outra condição: Nosso resultado não pode ser maior que$\left\lfloor\sqrt{a+b}\right\rfloor$. Ou seja, não podemos fazer um quadrado com mais peças do que as disponíveis.

Então, pegamos a menor das duas opções.

Podemos notar que isso é o mesmo que a formulação de Arnauld, pois se $a=b$ então $2\min(a,b)$$a+b$

Ruby , 36 bytes

->x,y{'%i'%[x+y,x-~x,y-~y].min**0.5}

Experimente online!

x-~xé uma versão para golfe 2*x+1; estamos subtraindo a negação de dois complementos de x de si mesma. Depois disso, estou apenas usando a fórmula desta resposta , mas recolhendo os dois mins aninhados em um e, em seguida, usando a formatação de string para truncar para um número inteiro.

Retina 0.8.2 , 50 bytes

O#`\d+
\d+
$*
(1*),(1?\1)1*
$1$2
^(^1|11\1)*1*
$#1

Experimente online! O link inclui casos de teste. Explicação:

O#`\d+

Classifique os números em ordem crescente. Vamos chamá-los le h.

\d+
$*

Converta para unário.

(1*),(1?\1)1*
$1$2

Computar l + max(h, l + 1). Isso é equivalente a 2 * min(b, w) + (b != w). Veja a resposta de @ Arnauld para saber por que isso funciona.

^(^1|11\1)*1*
$#1

Encontre a raiz quadrada inteira mais alta.

05AB1E , 8 7 bytes

Ë≠+ß·tï

Experimente online ou verifique todos os casos de teste .

Exlação:

Usa uma derivada trivial da fórmula @Arnauld usada em sua resposta JavaScript para salvar um byte:

Ë        # Check if the two values of the (implicit) input-pair are the same
         #  (1 if truthy; 0 if falsey)
 ≠       # Falsify (!= 1), so 1 becomes 0 and vice-versa
  +      # Add that to each of the (implicit) input-values
   ß     # Only leave the minimum of that
    ·    # Double it
     t   # Take the square root
      ï  # And truncate/floor it by casting to an integer

Japonês , 11 bytes

Solução JS do Porto de Arnauld. Recebe entrada como uma matriz.

ñÍÌÑ+Ur¦)¬f

Tente

ñÍÌÑ+Ur¦)¬f     :Implicit input of array U
ñ               :Sort by
 Í              :  Subtracting from 2
  Ì             :Last element (Yes, there are more straightforward ways of getting the minimum but I like this method and it doesn't cost any bytes)
   Ñ+           :Multiply by 2 and add
     Ur         :U reduced by
       ¦        :  Testing for inequality
        )       :End reduce
         ¬      :Square root
          f     :Floor

R , 32 bytes

min(sum(n<-scan()),2*n+1)^.5%/%1

Experimente online!

Toma be wde stdin.

Usa a fórmula desta resposta , mas aproveitando o comportamento de minassumir o mínimo de todos os seus argumentos.

Perl 6 , 29 26 bytes

{0+|sqrt 2*@_.min+[!=] @_}

Agradecimentos a Jo King por -3 bytes.

Experimente online!

Japonês , 10 bytes

Solução JS do Porto de Arnauld.

mV Ñ|U¦V ¬

Experimente online!