Imprima o menor quadrado quadrado perfeito


16

Esquadrar o quadrado é um processo de ladrilhar um quadrado usando apenas outros quadrados. Se esse ladrilho usar apenas quadrados de tamanhos diferentes, ele será considerado perfeito . O menor quadrado quadrado perfeito possível é um quadrado de 112x112 lado a lado usando 21 quadrados diferentes.

Eu criei a versão ascii art deste quadrado abaixo:

################################################################################################################
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ##                         #
#                                                ##                                 ############################
#                                                ##                                 ############################
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                ##                                 ##      ##                 #
#                                                #############################################                 #
#                                                #############################################                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ##         ##                 #
#                                                ##             ##               ###############################
#                                                ##             ##               ###############################
#                                                ##             ##               ##    ##                      #
#                                                ##             ##               ##    ##                      #
##################################################################               ##    ##                      #
##################################################################               ##    ##                      #
#                           ##                       ##       ###########################                      #
#                           ##                       ##       ###########################                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##       ##     ##                ##                      #
#                           ##                       ##################                ##                      #
#                           ##                       ##################                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ##                ##                      #
#                           ##                       ##              ###########################################
#                           ##                       ##              ###########################################
#                           ##                       ##              ##                                        #
#                           ##                       ##              ##                                        #
#                           ##                       ##              ##                                        #
#                           ###########################################                                        #
#                           ###########################################                                        #
#                           ##  ##                                   ##                                        #
#                           ##  ##                                   ##                                        #
##################################                                   ##                                        #
##################################                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
#                               ##                                   ##                                        #
################################################################################################################

O envio deve ser impresso no quadrado acima. Você pode imprimir um reflexo e / ou rotação do quadrado acima, se desejar. Uma nova linha à direita na última linha é permitida. Este é um , então a menor finalização ganha!


@ Otimizador De acordo com a pergunta e a Wikipedia, todos os pequenos quadrados devem ter tamanhos completamente diferentes.
Level River St

Nathan, minha submissão está de acordo com as regras? Eu usei uma espessura uniforme para todas as linhas.
21415

@DavidCarraher Tenho cada lado do quadrado delineado (para que os lados internos tenham vários sinais de libra). Além disso, você precisa usar em #vez deX
Nathan Merrill

11
Nathan, no avião, arestas não são fronteiras. Eles são segmentos de linha unidimensionais. Onde duas peças estão próximas, devemos ver uma única linha, não duas. Caso contrário, estamos transmitindo a ideia de que existe um espaço entre os ladrilhos.
7269

@DavidCarraher, enquanto isso é verdade, acho que faz mais sentido representá-lo dessa maneira.
Nathan Merrill

Respostas:


4

CJam, 88 84 83 bytes

'p:Ci_C*a*"2#   *%!"{i_S*a*{3af.|W%z}4*1$0=C#C*f{\+}..e<{_C&{oNo}|}%}/

Teste aqui.

Explicação

Aqui está a idéia básica: comece com um quadrado 112x112 "vazio". Agora percorra os quadrados em ordem de leitura (da esquerda para a direita, de cima para baixo). Adicione cada quadrado na primeira posição disponível. Depois, imprima todas as linhas concluídas - isso garante que apenas precisamos verificar a primeira linha (restante) para descobrir para onde o próximo quadrado vai.

A grade vazia é inicializada como ps, porque eu precisava de um caractere com um código de caractere maior que o espaço e #, e porque poderia reutilizar seu próprio código de caractere 112para o tamanho da grade inicial. Eu usei alguns dos truques de arte ASCII de Dennis aqui para preencher os pequenos quadrados na grade.

'p:C        e# Store the character 'p' in C.
i           e# Convert to its character code 112.
_C*a*       e# Generate a 112x112 array of p's.
"2#   *%!"  e# The 21 characters in this string correspond to the side lengths of
            e# the squares in the solution in reading order.
{           e# For each character in that string...
  i         e#   Convert to its character code (the current square's side length N).
  _S*a*     e#   Generate an NxN array of spaces.
  {         e#   Run this block 4 times. Each iteration turns the leading column into #'s
            e#   and then rotates the square by 90 degrees.
    3af.|   e#     For the first character in each row, take the bitwise OR with 3. 
            e#     This turns spaces into #'s and leaves #'s unchanged.
    W%z     e#     Reverse and transpose, which rotates by 90 degrees.
  }4*
  1$0=      e#   Copy the remaining grid and fetch the top row.
  C#        e#   Find the index of the first 'p'.
  C*        e#   Get a string of that many p's.
  f{\+}     e#   Prepend this string to each row of the small square, which gives the
            e#   square the correct horizontal position.
  ..e<      e#   Take the pairwise minimum of the square and the remaining grid. The p's
            e#   prepended to the square will leave the grid unchanged, but the spaces
            e#   and #'s in the square will overwrite the p's in the grid.
  {         e#   Map this block onto each row of the grid.
    _C&     e#     Copy the row and check if any p's are left.
    {oNo}|  e#     If NOT, the row is complete and we print it together with a newline.
            e#     This also removes the row from the grid, such that the top row for
            e#     the next iteration will have space for the next square left.
  }%
}/

9

Mathematica 360 426

O código funciona primeiro desenhando o quadrado perfeito de quadrados, rasterizando e binarizando a imagem e depois convertendo 0 em "#" e 1 em "".

A saída é retornada como caracteres ASCII comuns em uma tabela.

f@{n_,x_,y_}:=Rectangle[{x,y},{x+n,y+n}];t=Transpose;
Flatten[i=Rasterize[Graphics[{EdgeForm[{(*Thickness[.015],*)Black}],White,
f/@ Partition[{33,0,0,29,0,33,50,0,62,37,33,0,25,29,37,42,70,0,18,70,42,24,88,42,9,54,53,7,63,53,15,50,62,17,65,60,
11,82,66,19,93,66,35,50,77,27,85,85},3]
},ImageSize->70
],RasterSize->70]//Binarize//ImageData,1]/.{0:> "#",1:> " "};
GraphicsGrid@t@Most@Most@Rest@t[Most@Most[Rest[ArrayReshape[%,Dimensions[i]]]]]

pic1


Eu prefiro essa renderização, obtida pela exclusão Thickness[.015]

pic2


A espessura da linha não varia, o quadrado de 50x50 possui 48 caracteres de espaço e 48 caracteres de espaço para baixo, com uma borda de #'s. Ele colide com outros quadrados à direita e na parte inferior, desenhados de maneira semelhante. Onde dois quadrados que #circundam o lado de fora se encontram, você recebe um dobro #para as linhas internas. E os quadrados são de fato quadrados, eles têm o mesmo número de caracteres na vertical e na horizontal. O problema é a fonte. Esta resposta não está de acordo com as especificações. Se fosse aceita, a pergunta seria votada de perto para uma vitória não objetiva.
Level River St

As linhas são concebidas como unidimensionais, não bidimensionais. Eles não devem ser interpretados como bordas com espessura. Afinal, estamos dividindo uma região quadrada em sub-regiões quadradas. As fronteiras não devem ocupar nenhuma área.
`` #

Esse é o ponto. As linhas vão entre os quadrados , e o OP optou por representar os quadrados com bordas internas. Poderia ter ficado mais claro se ele optou por usar um símbolo diferente para cada quadrado (e possivelmente também o preencheu.) De qualquer forma, como você pode ver em perguntas recentes sobre bandeiras, entendimento usual (e todo o ponto da complexidade de komolgorov tag) é reproduzir fielmente a representação artística Ascii fornecida pelo OP, não fazer sua própria interpretação. Embora interessante, essa não é uma resposta válida. Muitos quadrados ainda têm diferentes números de caracteres em altura e largura.
Level River St

Lembra-me de Von Karman Ruas
Beta Decay

3

Ruby, 180 bytes

Versão golfe com base na versão não-golfada abaixo. Aproveitamos o fato de que normalmente existem 2 ou 3 quadrados com a mesma ycoordenada no canto superior esquerdo.

A primeira string mágica contém códigos ASCII para square sidelength+70e y increment +40. Ao encontrar um comprimento de linha quadrado (código Ascii> 67), assumimos que o próximo quadrado está na mesma coordenada y, e a coordenada x pode ser obtida incrementando a coordenada x atual em sidelength+2. Ao encontrar um incremento ay (código Ascii <67), incrementamos a coordenada y de acordo e redefinimos a coordenada x para a figura codificada na segunda seqüência mágica.

a=Array.new(112){?#*112}
x=y=1
j=9
'vg_CLW0SUO3J\,a]M*KV/T3n-Hi,e'.each_byte{|i|i>67?(s=i-70;(y..y+s-1).map{|i|a[i][x,s]=" "*s};x+=s+2):(x=')Fo_h){[~'[j-=1].ord-40;y+=i-40)}
puts a

Versão original

Esta solução (completamente não destruída) contém 315 bytes, excluindo linhas em branco e recuos desnecessários. Ele simplesmente cria uma matriz de 112 seqüências de 112 #e substitui o interior dos quadrados por espaços.

$a=Array.new(112){"#"*112}
def f(x,y,s)
  (y..y+s-1).map{|i|$a[i][x,s]=" "*s}
end

f(1,1,48)
f(51,1,33)
f(86,1,25)

f(86,28,6)
f(94,28,17)

f(51,36,13)
f(66,36,15)
f(83,36,9)

f(83,47,4)
f(89,47,22)

f(1,51,27)
f(30,51,23)
f(55,51,7)

f(64,53,5)
f(71,53,16)

f(55,60,14)

f(71,71,40)

f(30,76,2)
f(34,76,35)

f(1,80,31)

puts $a

3

C, 198 bytes

char*i="bSK8C?A;6HMI927B@Z4UQ",o[112][113],x,y,p,q,n;main(){for(;y<112;puts(o[y]),y++)for(x=-1;++x<112;)if(!o[y][x]){n=*i++-48;for(p=-1;++p<n;)for(q=-1;++q<n;)o[q+y][p+x]=p&&n-1-p&&q&&n-1-q?32:35;}}

(Ungolfed)

char *i="bSK8C?A;6HMI927B@Z4UQ", o[112][113], x, y, p, q, n;
main() {
  for ( ; y<112; puts(o[y]),y++) {
    for (x=-1; ++x<112; ) {
      if (!o[y][x]) {
        n = *i++ - 48;
        for (p=-1; ++p<n; ) {
          for(q=-1; ++q<n; ) {
            o[q+y][p+x] = (p && n-1-p && q && n-1-q) ? ' ' : '#';
          }
        }
      }
    }
  }
}

Tudo isso é feito através da varredura de uma matriz de 112 × 112 bytes (inicializada como zero). Sempre que encontra um byte zero, ele busca um valor da matriz ie adiciona uma caixa do tamanho correspondente. O byte extra em cada linha atua como um terminador de string, para que possamos usar puts()linhas inteiras em vez de usar putchar()caracteres individuais.

Provavelmente isso pode ser jogado um pouco mais, mas não acho que haja muita chance de vencer a resposta de steveverrill .

(link ideone)


+1 Este é um excelente conceito, muito melhor que o meu, em um idioma menos golfe. Eu acredito que pode ser capaz de vencer a minha resposta. Observe que você precisa imprimir a #quando !(p%(n-1)&&q%(n-1))eu também gostaria de reduzir o número de forloops de quatro para dois, usando x=i%113ey = i/113 etc.
Level River St

3

R, 293 291 287 282 bytes

a=array('#',112:113)
a[,113]='
'
for(g in list(c(0,0,49,34,26),c(27,85,7,18),c(35,50,14,16,10),c(46,82,5,23),c(50,0,28,24,8,1),c(52,63,6,17),c(59,54,15),c(70,70,41),c(75,29,3,36),c(79,0,32))){y=g[1];x=g[2]
for(b in g[0:1-2]){a[(y+2):(y+b),(x+2):(x+b)]=' '
x=x+b+1}}
cat(t(a),sep='')

Depois disso, percebi que tinha feito quase o mesmo processo que o @steveverrill. Uma matriz de '#' e em branco os interiores quadrados. Provavelmente pode espremer um pouco mais disso. O retorno de carro para a 3ª linha é significativo. Obrigado a AlexA por alguns.


Você faz referência apenas suma vez; portanto, não poderia fazer isso em for(g in list(...))vez de especificar sseparadamente antecipadamente? Eu acho que você iria economizar 2-3 bytes.
Alex A.

@AlexA. Obrigado, um exemplo óbvio que eu totalmente perdido
MickyT

2

Binário do MS-DOS, 137

O código a seguir será executado no MS-DOS se você o gravar em um arquivo chamado square.com, sem necessidade de compilação adicional (mas, como é fornecido em hexadecimal, você precisa "desexistir" primeiro):

fcba8f01b82370e83000bd1400bb4d018b1743438a27b02043e81e004d75
f1b97000ba8f3289d7b00daab00aaab82409aa83ea70cd214975ecc331c9
88e189ce89d788e1f3aa83c2704e75f4c3201d30e223218527190524063d
1f11521d0d811c0f321f09921c04b8141670101b4d12176619076f1905a6
141066120e4602288d100221022300021f

A saída será irreconhecível na maioria dos terminais, mas você pode redirecioná-la para um arquivo ( square.com > output.txt) e examiná-la em um editor de texto. Se você quiser algo mais legível, o código a seguir produzirá um square.com funcional se alimentado em debug.exe ( debug.exe < square.asm):

a
cld
mov dx,18f
mov ax,7023
call 13a
mov bp,14
mov bx,14d
mov dx,[bx]
inc bx
inc bx
mov ah,[bx]
mov al,20
inc bx
call 13a
dec bp
jnz 110
mov cx,70
mov dx,328f
mov di,dx
mov al,d
stosb
mov al,a
stosb
mov ax,924
stosb
sub dx,70
int 21
dec cx
jnz 125
ret
xor cx,cx
mov cl,ah
mov si,cx
mov di,dx
mov cl,ah
rep stosb
add dx,70
dec si
jnz 140
ret
db 20,1d,30,e2,23,21
db 85,27,19,05,24,6
db 3d,1f,11,52,1d,d
db 81,1c,f,32,1f,9
db 92,1c,4,b8,14,16
db 70,10,1b,4d,12,17
db 66,19,7,6f,19,5
db a6,14,10,66,12,e
db 46,02,28,8d,10,2
db 21,02,23,00,02,1f

n square.com
rcx
89
w
q

1

Matlab / Oitava, 258

Como sempre, matrizes. Eu codifiquei a linha e os índices da coluna de cada quadrado e do tamanho. Eu posso usá-los para preencher um grande quadrado em branco de #s.

r=[2,2,2,29,29,37,37,37,48,48,52,52,52,54,54,61,72,77,77,81];
c=[2,52,87,87,95,52,67,84,84,90,2,31,56,65,72,56,72,31,35,2];
s=[47,32,24,5,16,12,14,8,3,21,26,22,6,4,15,13,39,1,34,30];
z=ones(112)*35;
for i=1:20;
    z(r(i)+(0:s(i)),c(i)+(0:s(i)))=32;
end;disp([z,''])

0

Bash, 252

Todo codegolfer deve ser capaz de vencer um algoritmo de compactação de uso geral:

base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip

Agradeço a Toby Speight pela dica de usar entradas mais curtas (bobo me usado em gzipvez de gzip -9compressão) e uma string aqui.


2 mais curto com string aqui:base64 -d<<<H4sIAP9YuVUAA+3XQQrDIBAF0H1PUfD+d+yq0FA7GirGie/vdEZfkCy0lLl5lOfJlPaKoAUIBAKBQCAQCLwzOP3mfdFVv9IKBM4BTyQpGA0PE0AgcB8wzC3A6vS7egH4d5YH64WPtVGh/zvygj8agcCvQuufzA+2GoFA4AZgd9KCwS7Hzu3B7qQFO09rbXDEaa0NjtgLCAQCgUAgEAgEAoHz34dj8wLKvMUNbzEAAA==|gunzip
Toby Speight

E uma entrada mais curta nos leva a 251 :base64 -d<<<H4sIADyFv1UCA+3ZOw6EMAwFwH5PgeT735EOUSyfQAgOmVeCxUgusAkRbfOLqTARd0qAQCAQCAQCgcAvg80375dW/T+lQGAbsCCdgvsdXl0AAoHjgM8e7mUA92bKG+DtpAevDPflRsko7BXcKAQCD9+X3wOPCoFA4ABgnZ/OmcHTS+bw4PXzkV7Ak93KDdboVm6wxrOAQCAQCAQCgUAgENj++7BuZsq8xQ1vMQAA|gunzip
Toby Speight

Você tem certeza que funciona? Eu só entendo gunzip: command not found. Posso fazê-lo funcionar usando um subshell:, (base64 -d|gunzip)<<<...mas que ainda usa 258 bytes.
user2845840

Estranho, @ user284584 - algo de estranho no seu caminho? Eu testei o que eu escrevi (em um shell interativo, se isso faz uma diferença)
Toby Speight

oh deus ... tente copiar seu comentário e colá-lo de volta na concha. Stackexchange "prestativamente" inseriu 6 caracteres invisíveis, 3 cada um de u + 200c & u + 200b. Depois de removê-los, ele funciona.
user2845840
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.