Arte ASCII alinhada horizontalmente

20

Sua tarefa é aceitar como entrada dois "ASCII Art" s e alinhar cada obra de arte horizontal uma da outra.

Por exemplo, digamos que você tenha duas cadeias "abc\ndef"e "123\n456". Você precisa alinhá-los horizontalmente para produzir a string "abc123\ndef456". Estou chamando isso de" alinhar horizontalmente "porque, enquanto as entradas, quando impressas, ficam assim:

abc
def

e:

123
456

A saída, quando impressa, terá a seguinte aparência:

abc123
def456

Observe como uma entrada é colocada ao lado da outra.

Entrada

  • A entrada será uma string e pode ser como dois argumentos separados ou como uma sequência de strings.
  • Os caracteres nas artes terão códigos decimais no intervalo 32-126 (inclusive).
  • Não há problema em apoiar um número arbitrário de artes para alinhar em vez de apenas duas (mas obviamente você deve suportar pelo menos duas).
  • Você pode assumir que cada arte terá as mesmas dimensões e que conterá pelo menos uma linha.

  • Você deve ser capaz de suportar pelo menos 100x100 artes de personagens.

  • Para alinhar com as convenções no site, a ordem dos argumentos não importa. Não importa qual arte está à esquerda ou à direita.

Saída

  • A saída será as artes alinhadas, conforme mencionado acima, retornadas ou enviadas para o stdout.

  • Qualquer espaço em branco à direita em opcional.

  • Não deve haver separador visual entre as artes alinhadas.

As artes de entrada e saída devem ser \nou \rcadeias delimitadas. Seria excessivamente trivial permitir matrizes 2D.

As submissões podem ser funções ou programas completos.

Casos de teste:

"abc\ndef", "123\n456" -> "abc123\ndef456".

"qwertyuiop\n asdfghjkl", "Some other\nTextFiller" -> "qwertyuiopSome other\n asdfghjklTextFiller"

"  *  \n *** \n*****\n *** \n  *  \n", "  +  \n  +  \n+++++\n  +  \n  +  \n" -> "  *    +  \n ***   +  \n*****+++++\n ***   +  \n  *    +  \n"
code-golf  ascii-art 
— Carcinigenicado
fonte
1
Podemos usar um delimitador personalizado em vez de novas linhas? "|"ou seja " "?
— Rɪᴋᴇʀ
10
Vou dizer não, dado que arruinaria qualquer arte.
— Carcigenicate
Podemos usar em \rvez de \n?
— Adám 16/03/19
@ Adám Claro. Vou atualizar o texto.
— Carcigenicate
O espaço em branco à esquerda está ok?
— Adám 16/03/19

Respostas:

20

Tela , 1 byte

×

Experimente aqui!

— dzaima
fonte
6
Porque quem não tem apenas um builtin para isso? : P
— caird coinheringaahing
5
Isso nem é justo. ; -;
— 13188 totallyhuman
3
@KevinCruijssen No PPCG, geralmente é permitido receber entradas na ordem que você desejar, e para um idioma baseado em pilha, a ordem atual faz mais sentido do que reverter.
— Dzaima 16/0318
5
@KevinCruijssen embora Acabei de me lembrar que eu tenho um built-in para add inversa, por isso estou atualizando o post: p
— dzaima
2
Então o Canvas tem dois builtins para isso? OK porque não?
— caird coinheringaahing
6

Python 2 , 59 bytes

lambda y:'\n'.join(map(str.__add__,*map(str.splitlines,y)))

Experimente online!

— Rɪᴋᴇʀ
fonte
Também pode ser reduzido, removendo o espaço. : P
— totallyhuman
Se você deseja inserir e enviar listas de linhas, como antes, reduza para 30: Experimente on-line!
Fiquei lá por 5 minutos tentando decidir se eu deveria permitir isso. Como mostra a resposta de Haskell, isso reduziria o desafio a algo muito mais trivial. Suponho, porém, que as soluções excessivamente triviais não sejam tão populares.
— Carcigenicate
4

05AB1E , 6 bytes

|¶¡øJ»

Experimente online!

Explicação

|        # push all input into a list
 ¶¡      # split on newlines
   ø     # zip
    J    # join the rows to single strings
     »   # merge on newlines
— Emigna
fonte
Espaço um muito ruim entre as duas entradas não foi permitido :(.
— Magia Octopus Urna
3

Perl 5 -0F , 28 bytes

Inclui +2o \nargumento para -F(é "código", portanto, deve contar)

Dê entradas diretamente uma após a outra no STDIN.

#!/usr/bin/perl -0F\n
say@F[$%++,$_]for@F/2..$#F

Experimente online!

— Ton Hospel
fonte
3

Bash + coreutils, 14

  • 4 bytes salvos graças a @DavidFoerster.
paste -d "" $@

A entrada é fornecida como dois nomes de arquivo como parâmetros da linha de comando.

Experimente online .

— Trauma Digital
fonte
Você pode salvar 4 bytes:paste -d "" $@
— David Foerster 16/18
@DavidFoerster Thanks! Estranho - eu tentei isso mais cedo e não funcionou. Edit - Vejo agora - em vez de -d "", eu tentei -d"", o que obviamente não é diferente de-d
— Digital Trauma
2

APL (Dyalog Unicode) , SBCS de 9 bytes

Programa completo. Solicita (STDIN) qualquer lista de comprimento de \rcadeias delimitadas. As cadeias podem ser irregulares e de larguras diferentes, desde que tenham o mesmo número de linhas. Imprime (STDOUT) arte ASCII resultante.

⊃,/⎕FMT¨⎕

Experimente online!

⎕ prompt para entrada avaliada

⎕FMT¨ formato (avalie todos os caracteres de controle e retorne a matriz de caracteres) cada

,/ combiná-los horizontalmente (redução de catenação)

⊃ divulgar (porque a redução reduziu a classificação de 1 para 0)

— Adão
fonte
2

Java 8, 100 84 78 bytes

a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}

Sai com um ArrayIndexOutOfBoundsExceptionpara STDERR depois de imprimir o resultado em STDOUT, o que é permitido .

-6 bytes graças a @ OlivierGrégoire .

Explicação:

Experimente online.

a->b->{                        // Method with two String parameters and no return-type
  for(int i=0;;)               //  Loop over the substrings of the first input
    System.out.println(        //   Print:
     a.split("\n")[i]          //    The substring of the first input
     +b.split("\n")[i++]);}    //    plus the same-indexed substring of the second input
— Kevin Cruijssen
fonte
1
a->b->{for(int i=0;;)System.out.println(a.split("\n")[i]+b.split("\n")[i++]);}78 bytes. Nada é dito sobre não ter nenhum efeito colateral extra. Portanto, poderíamos simplesmente contar até que ocorra uma exceção.
— Olivier Grégoire
@ OlivierGrégoire Obrigado! E sair com um erro para STDERR é realmente permitido depois que ele imprimiu tudo no STDOUT.
— Kevin Cruijssen 16/03/19
2

Ruby , 48 bytes

->a,b{$;=$/;a.split.zip(b.split).map(&:join)*$/}

Experimente online!

Um lambda pegando duas cordas e retornando uma string. Configurando o splitdelimitador padrão como nova linha com$;=$/; não salva bytes, mas faz o resto parecer um pouco melhor.

Ruby , 49 bytes (arbitrariamente várias strings)

->s{s.map{|a|a.split$/}.transpose.map(&:join)*$/}

Experimente online!

Apenas por diversão. Acontece que podemos aceitar uma matriz de seqüências de caracteres a um custo adicional de apenas 1 byte.

— benj2240
fonte
2

JavaScript (ES6), 51 bytes

f=
(a,b)=>a.replace(/.+/g,a=>a+b.shift(),b=b.split`
`)
;document.write("<pre>"+f("abc\ndef", "123\n456")+"</pre>")
Expandir snippet

— Neil
fonte
2

Maravilha , 21 bytes

->#oN.zip#++.-> <>"
"

Exemplo de uso:

(->#oN.zip#++.-> <>"
")["abc#ndef" "abc#ndef"]

#n é usado em vez de \n indicar novas linhas.

Explicação

Versão detalhada:

(map #oN) . (zip #con) . (map split "#n")

Divida cada sequência na matriz de entrada ao longo de novas linhas, zip com concatenação de sequência e produza cada item.

— Mama Fun Roll
fonte
1

JavaScript (ES6), 52 bytes

Recebe entrada na sintaxe de currying (a)(b).

a=>b=>a.split`
`.map((s,i)=>s+b.split`
`[i]).join`
`

Experimente online!

— Arnauld
fonte
1

PowerShell , 51 49 bytes

param($a,$b)$a-split"
"|%{$_+($b-split"
")[$i++]}

Experimente online!

Recebe entrada como cadeias literais com novas linhas. Você também pode usar `n(o delimitador de nova linha no PowerShell, não\n ).

Primeiro, -splita string de entrada esquerda em novas linhas, que cria uma matriz, e percorre essa linha |%{...}. A cada iteração, concatenamos a string de entrada correta novamente dividida em novas linhas, indexadas e incrementadas.

Esses são deixados no pipeline e o implícito Write-Outputna conclusão nos dá saída como uma matriz de strings, que são impressas com novas linhas entre eles.

— AdmBorkBork
fonte
1

Japonês -R , 8 7 bytes

·íV· m¬

Tente

Explicação

             :Implicit input of strings U & V
·            :Split U on newlines
  V·         :Split V on newlines
 í           :Interleave
     m       :Map
      ¬      :  Join
             :Implicitly join with newlines and output

Alternativo

·Ë+V·gE

Tente

             :Implicit input of strings U & V
·            :Split U on newlines
 Ë           :Map over each element at index E and rejoin with newlines
   V·        :  Split V on newlines
     gE      :  Get the element at index E
  +          :  Append to the current element
             :Implicitly join with newlines and output
— Shaggy
fonte
1

Bash , 92 bytes

a=();for b;do c=;while IFS= read -r d;do a[c++]+=$d;done<<<"$b";done;printf '%s\n' "${a[@]}"

Experimente online!

Ungolfed:

array=()                             # Initialize the array
for argument in "${@}"; do           # Loop over the arguments list
  index='0'                          # Reset the index
  while IFS='' read -r 'line'; do    # Loop over every line of the current argument
    array[index]+="${line}"          # Append the line to its corresponding place
    (( index++ ))                    # Increment the index
  done <<< "${argument}"             # End while loop
done                                 # End for loop
printf '%s\n' "${array[@]}"          # Print array's content

Exemplos:

$ foo $'abc\ndef' $'123\n456'
abc123
def456

$ foo $'qwertyuiop\n asdfghjkl' $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller

$ foo \
>   $'  *  \n *** \n*****\n *** \n  *  \n' \
>   $'  +  \n  +  \n+++++\n  +  \n  +  \n'
  *    +  
 ***   +  
*****+++++
 ***   +  
  *    +  


# https://gist.github.com/nxnev/dad0576be7eb2996b860c320c01d0ec5
$ foo "$(< input1)" "$(< input2)" "$(< input3)" > output

Eu também tenho um menor, mas ele falhará se a segunda readinstrução retornar um valor diferente de zero.

Bash , 55 bytes

while IFS= read -r a;IFS= read b<&3;do echo "$a$b";done

Nota: <&3parece não funcionar tio.run

Este usa descritores de arquivo ( 1e 3) em vez de argumentos:

$ foo <<< $'qwertyuiop\n asdfghjkl' 3<<< $'Some other\nTextFiller'
qwertyuiopSome other
 asdfghjklTextFiller
— nxnev
fonte
1

Carvão , 8 bytes

ＰθＭ⌕θ¶→η

Experimente online! Link é a versão detalhada do código. Explicação:

 θ          First input
Ｐ           Print without moving the cursor
    θ       First input
     ¶      Literal newline
   ⌕        Find index
  Ｍ   →     Move that many squares right
       η    Implicitly print second input

Adicione 2 bytes para aceitar várias entradas:

ＦＡ«ＰιＭ⌕ι¶→

Experimente online! Link é a versão detalhada do código. Explicação:

 Ａ          Input
Ｆ «         Loop over all entries
   Ｐι       Print current entry
     Ｍ⌕ι¶→  Move to next entry

Adicione 4 bytes para aceitar entrada não preenchida:

ＰθＭ⌈Ｅ⪪θ¶Ｌι→η

Experimente online! Link é a versão detalhada do código. Explicação:

      θ         First input
       ¶        Literal newline
     ⪪          Split
    Ｅ           Map over each string
         ι      Current string
        Ｌ       Length
   ⌈            Maximum
  Ｍ       →     Move that many squares right
— Neil
fonte
1

Swift 4 , 119 bytes

func f(s:[String])->String{return s[0].split{$0=="\n"}.enumerated().map{$0.1+s[1].split{$0=="\n"}[$0.0]+"\n"}.joined()}

Explicação

func f(s: [String]) -> String {
    return s[0].split{ $0=="\n" }       //splitting the first string after every \n
    .enumerated()                       //create a tuple of offsets and elements
    .map {
        $0.1 +                          //current element
        s[1].split{$0 == "\n"}[$0.0] +  //splitting the second string + indexing
        "\n"                            //new line after every line
     }
     .joined()
}

Experimente online!

— Tamás Sengel
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.