Introdução

Kerning significa ajustar o espaçamento entre as letras de um texto. Como exemplo, considere a palavra Topescrita com os três glifos a seguir:

##### ..... .....
..#.. ..... .....
..#.. ..##. .###.
..#.. .#..# .#..#
..#.. .#..# .#..#
..#.. ..##. .###.
..... ..... .#...
..... ..... .#...

Poderíamos simplesmente preencher as lacunas entre os glifos com pontos e terminar com isso, mas as lacunas de alguma forma parecem muito grandes. Em vez disso, deslizamos os glifos para a esquerda para que eles quase se toquem:

#####........
..#..........
..#..##..###.
..#.#..#.#..#
..#.#..#.#..#
..#..##..###.
.........#...
.........#...

Isso parece muito melhor! Observe como a barra de Testá no topo da borda esquerda de o. Nesse desafio, sua tarefa é implementar um programa de kerning simples para esses glifos retangulares.

O processo de kerning

Considere duas matrizes retangulares de caracteres 2D .e #da mesma forma. Em nosso processo simples de kerning, primeiro colocamos as matrizes lado a lado, com uma coluna de .s no meio. Então, movemos cada um #na matriz direita um passo para a esquerda, até que alguns #s da matriz esquerda e direita sejam ortogonais ou diagonalmente adjacentes. O resultado do kerning é o passo antes de introduzirmos #s adjacentes . Sua tarefa é implementar esse processo.

Vamos dar um exemplo:

Inputs:
..###
#....
#....
..##.

...#.
...##
..###
....#

Process:
..###....#.
#........##
#.......###
..##......#

..###...#.
#.......##
#......###
..##.....#

..###..#.
#......##
#.....###
..##....#

..###.#.
#.....##
#....###
..##...#

..####.
#....##
#...###
..##..#

Na última matriz, temos novos pares adjacentes de #s, portanto a penúltima matriz é o resultado do processo de kerning.

Entrada e saída

Para simplificar, você só precisa manipular o kerning de dois glifos. Suas entradas são duas matrizes 2D retangulares, em um dos seguintes formatos:

• Matrizes 2D de números inteiros, com 0 em pé .e 1 em #.
• Sequências de linhas múltiplas terminadas .#.
• Matrizes de strings terminadas .#.
• Matrizes 2D dos caracteres .#.

Se as entradas forem tomadas como uma única sequência, você poderá usar qualquer delimitador razoável. No entanto, o delimitador deve ir entre as duas matrizes, o que significa que você não tem permissão para receber as duas entradas já emparelhadas linha a linha.

Sua saída é o resultado do processo de kerning aplicado a essas duas matrizes, que é uma matriz 2D retangular no mesmo formato que as entradas. Você pode adicionar ou remover qualquer número de colunas iniciais ou finais de .s, mas a saída deve ser retangular e ter a mesma altura que as entradas. É garantido que o processo de kerning termine antes que a borda esquerda da segunda entrada deslize sobre a borda esquerda da primeira entrada.

Regras e pontuação

A contagem de bytes mais baixa em cada linguagem de programação vence. Aplicam-se as regras padrão de código de golfe .

Casos de teste

Para ajudar na cópia e colagem, esses casos de teste são fornecidos como listas de seqüências de caracteres.

["#"] ["#"] -> ["#.#"]
["#.","..",".#"] ["##","..","##"] -> ["#..##",".....",".#.##"]
["..#","#..","#.."] ["...","..#","###"] -> ["..#..","#...#","#.###"]
["###.","##..","#...","...."] ["....","...#","..#.",".#.."] -> ["###..","##..#","#..#.","..#.."]
["..##...","#......","#......"] [".....##",".....##",".#...#."] -> ["..##..##","#.....##","#.#...#."]
["...#.",".....",".....",".....","....#"] [".....","....#","#....",".....","....."] -> ["...#..",".....#",".#....","......","....#."]
["..#..",".....",".....",".....","....#"] [".....","....#","#....",".....","....."] -> ["..#..","....#","#....",".....","....#"]
["######","#.....","#.....","#.....","######"] ["......",".....#",".#...#",".....#","......"] -> ["######..","#......#","#..#...#","#......#","######.."]
["######","#.....","#.....","#.....","######"] ["......","......",".#....","......","......"] -> ["######","#.....","#.#...","#.....","######"]
["#...#","#..#.","#.#..","##...","#.#..","#..#.","#...#"] ["...#.","..#..",".#...",".#...",".#...","..#..","...#."] -> ["#...#..#","#..#..#.","#.#..#..","##...#..","#.#..#..","#..#..#.","#...#..#"]

APL (Dyalog Classic) , 40 39 bytes

-1 graças a Erik, o Outgolfer

{⌈⌿↑⍺(⍉(1-⌈/+⌿+∘×⍨2⌈/0,+/⌈\↑(⌽⍺)⍵)↑⍉⍵)}

Experimente online!

Python 3 , 154 bytes

lambda a,b,p=".":[c.rstrip(p)+d.lstrip(p).rjust(max(len((d+c).strip(p))for(c,d)in zip((a*3)[1:],b[:-1]+b+b[1:]))+1-len(c.rstrip(p)),p)for(c,d)in zip(a,b)]

Experimente online!

Retina , 223 bytes

+`(.+)¶(¶(.+¶)*)(\W+(¶|$))
$2$1i$4
T`.`i`\.*i\.*
+`(¶(.)*#.*i.*¶(?<-2>.)*)i
$1@
+`(¶(.)*)i(.*¶(?<-2>.)*(?(2)(?!))#.*i)
$1@$3
T`i@`.`i*[#@]+i
mT`.`i`\.+i+$
msT`i`.`.*^\W+$.*
+`(\b(i+)\W+\2i*)i
$1.
+s`\bi((i+).+\b\2\b)
.$1
i

Experimente online! O link inclui casos de teste e script de cabeçalho para reformatá-los no formato de entrada preferido de duas seqüências delimitadas por nova linha. Isso parece muito longo, mas provavelmente há um caso de ponta que eu negligenciei, mas pelo menos passa em todos os casos de teste agora. Explicação:

+`(.+)¶(¶(.+¶)*)(\W+(¶|$))
$2$1i$4

Junte as duas matrizes de entrada usando uma letra icomo separador. (Isso permite o uso \We \bmais tarde.)

T`.`i`\.*i\.*

Altere todos os .s para is na associação.

+`(¶(.)*#.*i.*¶(?<-2>.)*)i
$1@

Altere todos os is abaixo de #s para @s.

+`(¶(.)*)i(.*¶(?<-2>.)*(?(2)(?!))#.*i)
$1@$3

Altere todos os is acima de #s para @s.

T`i@`.`i*[#@]+i

Altere todos os @s para .s, mais todos os is adjacentes a @s ou #s.

mT`.`i`\.+i+$

Se não houver #depois de um i, altere as .costas adjacentes para um inovamente.

msT`i`.`.*^\W+$.*

Se houver uma linha sem is, altere todos os is para .s, pois não há nada a fazer aqui.

+`(\b(i+)\W+\2i*)i
$1.

Calcule o número mínimo de is em qualquer linha.

+s`\bi((i+).+\b\2\b)
.$1

Propague para as outras linhas.

i

Exclua os is, executando o kerning necessário.