Lay out the Carpet

40

Inspirado por esta pergunta SO .

Desafio:

Entrada:

  • Uma strings
  • Um caracterec

Saída:

Crie uma arte ASCII de diamante em forma de quadrado nas quatro direções, com o primeiro caractere da seqüência no centro e indo para fora. Que fica dentro de um tapete quadrado de arte ASCII, com o personagem como preenchedor. Isso pode parecer bastante vago, então aqui está um exemplo:

Entrada: = , = Saída:sstringc.

..........g..........
........g.n.g........
......g.n.i.n.g......
....g.n.i.r.i.n.g....
..g.n.i.r.t.r.i.n.g..
g.n.i.r.t.s.t.r.i.n.g
..g.n.i.r.t.r.i.n.g..
....g.n.i.r.i.n.g....
......g.n.i.n.g......
........g.n.g........
..........g..........

Regras do desafio:

  • A string de entrada também pode ser uma lista de caracteres
  • A saída também pode ser uma lista de linhas de sequência ou matriz de caracteres
  • A string e o caractere de entrada têm a garantia de que não estão vazios
  • A cadeia é garantida para não conter o caractere
  • Tanto a string quanto o caractere só podem ser impressos em ASCII (intervalo unicode [32,126], espaço '' para e incluindo o til '~')

Regras gerais:

  • Isso é código-golfe , então a resposta mais curta em bytes vence.
    Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
  • As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
  • As brechas padrão são proibidas.
  • Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
  • Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

Entrada: = , = Saída:sc =11111c=0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

Entrada: = , = Saída:sc12345ABCDEFc#

####################F####################
##################F#E#F##################
################F#E#D#E#F################
##############F#E#D#C#D#E#F##############
############F#E#D#C#B#C#D#E#F############
##########F#E#D#C#B#A#B#C#D#E#F##########
########F#E#D#C#B#A#5#A#B#C#D#E#F########
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
F#E#D#C#B#A#5#4#3#2#1#2#3#4#5#A#B#C#D#E#F
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
########F#E#D#C#B#A#5#A#B#C#D#E#F########
##########F#E#D#C#B#A#B#C#D#E#F##########
############F#E#D#C#B#C#D#E#F############
##############F#E#D#C#D#E#F##############
################F#E#D#E#F################
##################F#E#F##################
####################F####################

Entrada: = , = Saída:sc@+-|-o-|-Oc:

::::::::::::::::::O::::::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
O:-:|:-:o:-:|:-:+:@:+:-:|:-:o:-:|:-:O
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::::::O::::::::::::::::::

Entrada: = , = Saída:scABcc

ccBcc
BcAcB
ccBcc

Entrada: = , = Saída:sc~cX

~

Entrada: = , = Saída:sc/\^/\cX

XXXXXXXX\XXXXXXXX
XXXXXX\X/X\XXXXXX
XXXX\X/X^X/X\XXXX
XX\X/X^X\X^X/X\XX
\X/X^X\X/X\X^X/X\
XX\X/X^X\X^X/X\XX
XXXX\X/X^X/X\XXXX
XXXXXX\X/X\XXXXXX
XXXXXXXX\XXXXXXXX
code-golf  string  ascii-art 
— Kevin Cruijssen
fonte
A cadeia pode conter espaços?
— Emigna 26/03
11
@Emigna Sim, todos os ASCII imprimíveis (intervalo unicode [32.126]) são caracteres de entrada válidos.
— Kevin Cruijssen 26/03
11
Isso se torna maravilhoso para depurar se você usar caracteres que se pareçam visualmente com um único caracter, por exemplo ()()().
— Filip Haglund
O que deve acontecer se $ s $ estiver vazio?
— Solomon Ucko
@SolomonUcko Na seção de regras: " A string de entrada e o caractere são garantidos como não vazios " :)
— Kevin Cruijssen

Respostas:

6

R , 118 95 92 bytes

function(a,d,n=length(a),I=c(n:1,1:n)[-n])for(i in I-1)write(c(a,d)[pmin(I+i,n+1)],1,n*2,,d)

Experimente online!

Graças a:

  • Giuseppe por corrigir um erro e um golfe
  • Aaron Hayman por 22 bytes de golfe
— Kirill L.
fonte
Acho que preciso largar minha aversão a forloops em R, pelo menos para jogar golfe.
— Aaron Hayman
@ Giuseppe, obrigado, eu não deveria ter tanta preguiça quanto à inclusão de casos de teste extras!
— Kirill L.
11
Isso para 98 parece mais próximo da sua solução do que da minha Experimente online!
— Aaron Hayman
11
pode tirar outros dois com um pouco de rearranjo: Experimente online!
— Aaron Hayman
11
@AaronHayman ou então esse 92 byter combinando a pminlógica com o rearranjo :-)
— Giuseppe
5

R , uma versão feia de 118 bytes

Permitindo que a entrada seja um vetor de caracteres únicos e produzindo uma matriz em vez de imprimir uma bela arte ASCII.

function(s,C,l=length(s),L=4*l-3,k=2*l-1,y=abs(rep(1:k,L)-l)+abs(rep(1:L,e=k)-k)/2+1)matrix(ifelse(y%%1|y>l,C,s[y]),k)

Experimente online!

R , 161 157 bytes

salvou 4 bytes usando ifelse em vez de modificar condicionalmente y 

function(S,C,l=nchar(S),L=4*l-3,k=2*l-1,y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1)cat(rbind(matrix(ifelse(y%%1|y>l,C,el(strsplit(S,''))[y]),L),'
'),sep='')

Experimente online!

ungolfed e comentou

function(S,C){
    s=el(strsplit(S,''))
    l=nchar(S)
    L=4*l-3
    k=2*l-1
    y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1 # distance from centre
    y[!!y%%1]=l+1  # set non integers to one more than length of string
    y[y>l]=l+1     # set number beyond length of string to one more than length of string
    M = rbind(matrix(c(s,C)[y],L),'\n') # build matrix and add line returns
    cat(M,sep='') # print the matrix as a string
}

hmmm, parece ser a resposta mais longa até agora!

— Aaron Hayman
fonte
Oh querido, deveria ter olhado para a pergunta melhor
— Aaron Hayman
11
@KevinCruijssen Eu o corrigi agora
— Aaron Hayman
11
para +15 bytes, você pode fazer sua resposta feia ascii-art: Experimente online!
— Giuseppe
4

05AB1E , 15 11 bytes

.sûsζøsýí€û

Experimente online! ou como um conjunto de testes

Explicação

.s            # push suffixes of input
  û           # palendromize this list
   sζ         # transpose using the second input as filler
     ø        # transpose back
      sý      # merge each on the second input
        í     # reverse each row
         €û   # palendromize each row
— Emigna
fonte
11
@KevinCruijssen: Sim. Felizmente, não custou nenhum bytes para corrigi-lo. Ainda sinto que deveria haver uma maneira melhor de fazer isso, então continuarei procurando.
— Emigna 26/03
" Saída também pode ser uma lista de linhas de seqüência de caracteres ou matriz de caracteres ", para que você possa mover o »para o rodapé. :)
— Kevin Cruijssen 26/03
@KevinCruijssen Ah, certo. Olhei para aquela parte. Obrigado :)
— Emigna 26/03
4

J , 35 34 33 bytes

,{~1j1(}:@#"1{:(<*-)1-|+/|)i:@-&#

Experimente online!


-&#cs
i:
1-|+/|
{: (<*-)-&#

 0  0 _1  0  0
 0 _1 _2 _1  0
_1 _2 _3 _2 _1
 0 _1 _2 _1  0
 0  0 _1  0  0

Os índices negativos começam em -1, como em python. A única coisa que resta é inserir as colunas de zeros.

1j1( #"1
  }:@
,{~cs

Muito obrigado a Galen Ivanov pelo algoritmo.

— FrownyFrog
fonte
Você se importaria de adicionar uma explicação? Eu não estou tão familiarizado com J.
— Kevin Cruijssen 29/03
4

K (ngn / k) , 38 bytes

{1_',/'y,''2{+x,1_|x}/(#x)'1_,/+y,'|x}

Experimente online!

{ }função com argumentos x(a sequência s ) e y(o caractere c )

|x marcha ré x

y,'anexar ya cada

+ transpor

,/ concat

1_ soltar primeiro caractere

Neste ponto, temos uma sequência de xocorrências length ( ) yseguidas pelos caracteres dex

#x Comprimento de x

(#x)' janela deslizante de muitos caracteres consecutivos

2{ }/ faça duas vezes

+x,1_|xjunte x-se ao invertido xsem seu primeiro elemento e transponha

y,''anexar ya cada um

,/' concat cada

1_' solte um de cada

— ngn
fonte
3

Japonês , 15 bytes

Retorna uma matriz de linhas

Ôå+ ®¬qV êÃûV ê

Tente

Ôå+ ®¬qV êÃûV ê     :Implicit input of strings U=s & V=c
Ô                   :Reverse U
 å+                 :Prefixes
    ®               :Map
     ¬              :  Split
      qV            :  Join with V
         ê          :  Palindromise
          Ã         :End map
           ûV       :Centre pad each string with V, to the length of the longest
              ê     :Palindromise
— Shaggy
fonte
3

Carvão , 15 bytes

ＵＢηＥθ✂θκ‖Ｏ↑←ＵＥ¹

Experimente online! Link é a versão detalhada do código. Originalmente enviado como um comentário na postagem da sandbox agora excluída . Explicação:

ＵＢη

Defina o plano de fundo para a segunda entrada c.

Ｅθ✂θκ

Mapeie a primeira entrada spara gerar todos os sufixos e imprimi-los implicitamente em linhas separadas.

‖Ｏ↑←

Reflita horizontalmente e verticalmente.

ＵＥ¹

Adicione espaço extra horizontalmente.

— Neil
fonte
3

Ruby , 95 84 75 bytes

->a,c{(1...2*z=a.size).map{|i|s=a[j=(z-i).abs,z]*c+c*2*j;s.reverse.chop+s}}

Experimente online!

Leva a string de entrada como uma matriz de caracteres. Retorna uma matriz de seqüências de caracteres.

— Kirill L.
fonte
2

PowerShell , 120 bytes

param($s,$c)($s,(($l=$s.length-1)..0+1..$l|%{($x=$c*(2*$_))+($s[($_,($l..$_+($_+1)..$l))[$_-ne$l]]-join$c)+$x}))[$l-gt0]

Experimente online!

Alguns dias, ter intervalos de índice em vez de fatias realmente dói. Hoje é um daqueles dias. Devido aos intervalos conjugados que atrapalham ao lidar com elementos únicos (por exemplo, retornando 0..0 + 1..0), a caixa especial é usada para evitá-la completamente (ao custo de muitos bytes).

— Veskah
fonte
2

PowerShell , 82 83 bytes

+2 bytes graças Veskah: o erro de maiúsculas e minúsculas corrigido

-1 byte: a regra Input-string may also be a list of charactersusada

$c,$s=$args
($s|%{(-join$s|% s*g $i)+$c*$i++})[($r=$i..0+1..$i)]|%{"$_"[$r]-join$c}

Experimente online!

Menos golfe:

$c,$s=$args
$southEast = $s|%{
    (-join$s|% substring $i) + $c*$i++
}
$range=$i..0+1..$i
$southEast[$range]|%{
    "$_"[$range]-join$c
}
— confuso
fonte
11
Parece que isso quebra no caso de um único caractere. Há apenas uma linha vazia no link TIO para~
— Veskah
De fato. Obrigado!
— mazzy 26/03
2

Pip , 24 20 bytes

QPRV:_JbMa@>RV,#aZDb

Use o -lsinalizador para obter uma saída legível por humanos. Experimente online!

Explicação

QPRV:_JbMa@>RV,#aZDb
                      a,b are cmdline args (implicit)
                a     1st cmdline arg (the string)
               #      Length
              ,       Range
            RV        Reverse
         a@>          Take slices of a starting at those indices
                 ZDb  Zip the list of slices together, filling out missing values in
                      the matrix with b (the character)
        M             To each row, map this function:
     _Jb               Join on b
  RV:                 Reverse (making top row the bottom and vice versa)
QP                    Quad-palindromize: reflect downward and rightward, with overlap

Por exemplo, com entradas de abcde .:

RV,#a
 [3 2 1 0]
a@>
 ["d" "cd" "bcd" "abcd"]
ZDb
 [['d 'c 'b 'a] ['. 'd 'c 'b] ['. '. 'd 'c] ['. '. '. 'd]]
_JbM
 ["d.c.b.a" "..d.c.b" "....d.c" "......d"]
RV:
 ["......d" "....d.c" "..d.c.b" "d.c.b.a"]
QP
 ["......d......" "....d.c.d...." "..d.c.b.c.d.." "d.c.b.a.b.c.d" "..d.c.b.c.d.." "....d.c.d...." "......d......"]
— DLosc
fonte
2

Anexo , 57 bytes

${q:=#x-1Bounce!Bounce@Join&y@PadLeft&y&#x=>x[q::(q::0)]}

Experimente online! Saída é uma lista de linhas.

Explicação

?? parameters: x, y
${
    ?? q is length of x - 1
    q:=#x-1
    ?? Reflect, collapsing middle:
    Bounce!
        ?? Function:
            ?? Reflect,
            Bounce@
            ?? Joined by y,
            Join&y@
            ?? padded to the length of x with y
            PadLeft&y&#x
        ?? Mapped over
        =>
            ?? The elements of x at
            x[
                ?? decreasing range from q to
                q::(
                    ?? each element in the range from q to 0
                    q::0
                )
            ]
}
— Conor O'Brien
fonte
2

Perl 6 , 79 bytes

->\c{{map {join c,g $_ X||c},g .[^*X+(^$_,)]}o*.comb}
my&g={.[$_-1...0...$_-1]}

Experimente online!

Codeblock anônimo que recebe entrada com curry (like f(char)(string)) e retorna uma lista de linhas. Eu acho que uma abordagem diferente seria mais curta.

Explicação:

my&g={.[$_-1...0...$_-1]}  # Helper function to palindromise a list
->\c{                                                }  # Code block that takes a char
     {                                       }o*.comb   # And returns a function
                                .[^*X+(^$_,)]  # Get all prefixes with end padding
                                               # e.g. "str" => [["r",Nil,Nil]
                                                                ["t","r",Nil]
                                                                ["s","t","r"]]
                              g   # Palindromise the lsit
       map {                },    # Map each element to
                     $_ X||c      # Replace all Nils with the character
                   g              # Palindromise it
            join c,               # And join by the character
— Brincadeira
fonte
1

JavaScript (Node.js) , 143 bytes

(s,c)=>{q=Math.abs;m=(l=s.length*4-3)-1;for(i=j=0;j<l/2;(i=(++i)%l)?0:++j){p=s[q(i-m/2)/2+q(j-m/4)];process.stdout.write((i?"":"\n")+(p?
p:c))}}

Experimente online!

Um pouco mais de reflexão levaria ao cálculo em termos de uma matriz unidimensional e menos bytes.

— Igor Sowinski
fonte
1

Kotlin , 250 bytes

Nota: O Kotlin tio atualmente falha ao retornar uma nova classe, portanto esse código obtém uma exceção de ponteiro nulo. Isso também ocorre para os códigos que eu publiquei anteriormente que funcionavam naquele momento. Suponho que ele acabará sendo corrigido, mas não foi possível encontrar um contato de suporte para reportar o problema. Também pode ser executado aqui .

{s:String,c:Char->val h=s.length*2-1
val w=h*2-1
val m=Array(h){Array(w){c}}
for(i in s.indices)for(r in 0..h-1){val o=(i-Math.abs(h/2-r))*2
if(o>=0){m[r][w/2+o]=s[i].toChar()
m[r][w/2-o]=s[i].toChar()}}
m.map{it.joinToString("")}.joinToString("\n")}

Experimente online!

— JohnWells
fonte
Você pode entrar em contato @ Dennis em O chat ninteenth Byte . Ele é o moderador do TIO. Além disso, permito retornar uma lista de seqüências de caracteres em vez de realmente imprimir, então acho (não tenho certeza) que você pode remover a .joinToString("\n")contagem de bytes (e fazer isso no rodapé fora da função).
— Kevin Cruijssen 29/03
1

Consulta TSQL, 191 bytes

No MS-SQL Server Management Studio, pressione Ctrl-T antes de executar esta consulta, isso mudará a saída para texto.

Este script está construindo a saída da esquerda para a direita em uma "string" longa, calculando o valor a ser colocado em cada posição. A saída é limitada a 4096 caracteres.

Golfe:

SELECT
string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@y),'')FROM(SELECT
abs(k/2-n%k)+abs(k/2-n/k)h,*FROM(SELECT
number n,len(@)*2-1k,*FROM spt_values)c)d
WHERE n<k*k and'P'=type

Ungolfed:

USE master
DECLARE 
@y char='.',
@ varchar(20) = 'abcd'

SELECT
  string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@y),'')
FROM
(
  SELECT
    abs(k/2-n%k)+abs(k/2-n/k)h,*
  FROM
  (
    SELECT
      number n,
      len(@)*2-1k,*
    FROM spt_values
  )c
)d
WHERE n<k*k and'P'=type

Eu tive que fazer algumas alterações para formatar a saída na versão online.

Experimente online

— t-clausen.dk
fonte
1

JDK (Java) , 213 199 198 bytes

a->b->{int i=0,l=a.length()-1;String s=a,r[]=new String[l-~l],p;for(;i<=l;s=s.substring(1))r[l+i]=r[l-i]=new StringBuffer(p=b.join(b,s.split(""))+b.repeat(2*i++)).reverse()+p.substring(1);return r;}

Experimente online!

-14 bytesObrigado a @KevinCruijssen
-1 byteobrigado a @ceilingcat

Ungolfed

a->
    b-> {
        int i = 0, l = a.length() - 1;
        String s = a, r[]=new String[a.length()*2-1],p;
        for (; i<=l; s=s.substring(1))
            r[l+i]
              = r[l-i++]
              =   new StringBuffer(
                                   p =   String.join(b,s.split(""))
                                       + b.repeat(2*i)
                                  ).reverse()
                + p.substring(1);
        return r;
    }
— Sara J
fonte
11
Boa resposta, você pode jogar com 14 bytes abaixo de 200 . :)
— Kevin Cruijssen 03/04
@KevinCruijssen Bem visto, obrigado!
— Sara J
@ceilingcat Bom pensamento, obrigado!
— Sara J
1

Wolfram Language (Mathematica) , 68 bytes

Table[#[[1+Abs@y+Abs@x/2]]/._@__:>#2,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&

Experimente online!

Pega uma lista de caracteres (junto com o caractere de preenchimento) como entrada e gera uma matriz de caracteres.

Table[                              ,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&    (* make a (2*len-1 x 4*len-3) table centered at (0,0) *)
      #[[               ]]                                              (*  where the value at each point is the string indexed at *)
         1+Abs@y+Abs@x/2                                                (*   (1 + |y-coordinate| + |x-coordinate|/2) *)
                          /._@__:>#2                                    (*  if that indexing fails, use the filler character instead *)

Para pegar o índice da lista de caracteres, usamos list[[index]], que é expandido internamente para Part[list, index]. Se o índice for válido, essa expressão será avaliada como o valor nesse índice. Caso contrário, se o índice não for um número inteiro ou estiver fora do intervalo, a expressão permanecerá sem avaliação.
O padrão mais simples (mais curto) que corresponde, Part[...]mas não um caractere é _@__, que corresponde a qualquer expressão com um ou mais argumentos.

— attinat
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.