12

Este é meu amigo Thomas. Ele é meia árvore, meio emoticon.

|    |
| :D |
|    |

Ele está sozinho. Vamos fazer alguns amigos para ele!

Dado um ícone baseado em texto como entrada (por exemplo ಠ_ಠ, :P, >_>, não 😀, 🤓ou 🐦), a saída treemote correspondente.

O comprimento de um treemote é quantos caracteres ele possui (basicamente a maioria das funções de comprimento integradas para strings). Então ಠ_ಠtem comprimento 3.

A sintaxe para um treemote de comprimento né a seguinte:

|< 2+n spaces>| * ceil(n/2)
| <emote> | (note the spaces)
|< 2+n spaces>| * ceil(n/2)

Portanto, qualquer treemote de comprimento 3 se pareceria com:

|     |
|     |
| ಠ_ಠ |
|     |
|     |

Ele tem ceil(n/2)segmentos de tronco separados por nova linha em ambos os lados, cada um com 2 + nespaços internos.

Desafio: dado o emoticon baseado em texto, produza o treemote correspondente.

Outras regras:

Isso é código-golfe , o que significa que quero que você escreva um código curto.
Lacunas padrão não permitidas.
Você deve suportar caracteres não-ascii, a menos que seu idioma não possa lidar com eles.

Casos de teste:

^_^

|     |
|     |
| ^_^ |
|     |
|     |

\o/

|     |
|     |
| \o/ |
|     |
|     |


(✿◠‿◠)

|        |
|        |
|        |
| (✿◠‿◠) |
|        |
|        |
|        |


D:

|    |
| D: |
|    |


( ͡° ͜ʖ ͡°)


|             |
|             |
|             |
|             |
|             |
|             |
| ( ͡° ͜ʖ ͡°) |
|             |
|             |
|             |
|             |
|             |
|             |

code-golf ascii-art

— Rɪᴋᴇʀ
fonte

As novas linhas à direita são permitidas?

— R. Kap

Assumimos que emoticons de 1 caractere não existem?

— Adám 17/05/19

Por "emoticon baseado em texto", você quer dizer emoticon ascii?

— Downgoat 17/05

@Downgoat no. Veja o ಠ_ಠcaso de teste.

— Rɪᴋᴇʀ 17/05/19

6

Talvez adicionar um caso de teste com um comprimento diferente de 3 ...

— SuperJedi224

4

05AB1E , 27 25 bytes

Código:

g©Ìð×"|ÿ|
"®;î×©„| Â¹s¶®J

Explicação:

g                  # Push the length of the input string.
 ©                 # Copy that to the register.
  Ì                # Increment by 2.
   ð×              # Multiply by spaces.
     "|ÿ|\n"       # ÿ is used for interpolation and push the string "|spaces|\n".
                   #
 ®                 # Retrieve the value from the register.
  ;î               # Divide by 2 and round up.
    ×              # Multiply that by "|spaces|".
     ©             # Copy this into the register.
      „|           # Push the string "| ".
         Â         # Bifurcate, pushing the string and the string reversed.
          ¹s       # Push input and swap.
            ¶      # Push a newline character.
             ®J    # Retrieve the value from the register and join everything in the stack.
                   # Implicitly output this.

Usa a codificação CP-1252 . Experimente online! .

— Adnan
fonte

Introduzir ( ͡° ͜ʖ ͡°)retorna resultados engraçados.

— Shaun Wild

@ShaunWild Sim, é um caso de teste estranho, porque ( ͡° ͜ʖ ͡°)em si é de 11 caracteres, mas parece 8 caracteres.

— Adnan

4

Python 3.5, 76 75 73 bytes:

( Obrigado ao Blue por uma dica que salvou 2 bytes! )

def i(n):q=len(n);z=('|'+' '*(2+q)+'|\n')*-(-q//2);print(z+'| '+n+' |\n'+z)

Experimente Online! (Ideona)

Além disso, aqui está uma versão Python 2.7.5 não - competitiva, pois é muito maior em 87 bytes .

def i(n):q=len(n.decode('utf-8'));z=('|'+' '*(2+q)+'|\n')*-(-q/2);print z+'| '+n+' |\n'+z

Isso ocorre porque a codificação padrão do Python 2 é asciie, portanto, caracteres como ಠfora do intervalo de 128 pontos unicode contam como mais de 1 byte ( list('ಠ')rendimentos ['\xe0', '\xb2', '\xa0']). A única solução alternativa em que pude pensar nisso foi decodificar a entrada usando utf-8e depois seguir com essa utf-8sequência decodificada.

Experimente esta versão online do Python 2! (Ideona)

— R. Kap
fonte

Você pode se livrar das parênteses em torno de (- (- q // 2)) por 2 bytes. Eu acho que você pode economizar mais 2 bytes mudando para o Python 2.7. Ele não precisa do segundo / em // e apenas um espaço na instrução print.

— Azul

@ Blue Sim, você está certo, eu posso remover o segundo par de parênteses. No entanto, eu não preciso o segundo /em //fazer o ceil divisão.

— R. Kap

como eu estava dizendo, em Python 2.7 a divisão inteira é feita com 1 /

— Blue

@ Blue Oh, eu assumi que você estava dizendo que não preciso disso no Python 3. Bem, nesse caso, então irei para o Python 2. Obrigado pelas dicas! :)

— R. Kap

@ Blue Se for esse o caso, como você faz a divisão de flutuação no Python 2?

— R. Kap

3

Dyalog APL , 37 34 33 bytes

{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×≢⍵}

Usuários do Chrome: veja nota de rodapé *

Casos de teste

      f←{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×≢⍵}

      f,'☺' ⍝ the , is necessary to create a 1 char string instead of a character scalar
|   |
| ☺ |
|   |
      f':D'
|    |
| :D |
|    |
      f'^_^'
|     |
|     |
| ^_^ |
|     |
|     |

* O ^{Chrome exibe incorretamente os dois caracteres ≢⍵(U + 2262, U + 2375) como ≢⍵(U + 2261, U + 0338, U + 2375) em vez de como ̸≡⍵(U + 0338, U + 2262, U + 2375). versão de exibição para Chrome:{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×̸̸≡⍵}}

— Adão
fonte

1

+1 por ter emoticons dentro do seu próprio código {⍺⍵⍺} ¨b

— Value Ink

3

Ah, {⍺⍵⍺}¨bé o emoticon "Programador da APL na sua quinta xícara de café dando um joinha".

— Lynn

2

V, 60 57 bytes

I| A |ByWo=ceil(len(""")/2.0)
 dF.d0kwviWr Yu@-pH@-P

Infelizmente, V não tem quase nada em termos de operações matemáticas. As funções de divisão e teto aumentaram drasticamente a contagem de bytes.

Como contém um monte de imprimíveis desagradáveis, eis um hexdump reversível:

00000000: 497c 201b 4120 7c1b 4279 576f 123d 6365  I| .A |.ByWo.=ce
00000010: 696c 286c 656e 2822 1222 2229 2f32 2e30  il(len("."")/2.0
00000020: 290d 201b 6446 2e64 306b 7776 6957 7220  ). .dF.d0kwviWr 
00000030: 5975 402d 7048 402d 50                   Yu@-pH@-P

Explicação:

I| A |                                #Add surrounding bars
      B                               #Move back
       yW                             #Yank a word
         o                            #Open a new line
          <C-r>=                      #Evaluate

          <C-r>"                      #Insert the yanked text into our evaluation
ceil(len("      ")/2.0)<cr>           #Evaluate ceil(len(text)/2) and insert it

 dF.                                  #Append a space and delete backward to a (.)
                                      #By default, this will be in register "-
    d0                                #Delete this number into register a
      kw                              #Move up, and forward a word
        viWr                          #Replace the emoticon with spaces
             Yu                       #Yank this line, and undo 
                                      #(so we can get the emoticon back)
               @-p                    #Paste this text "- times.
                  H                   #Move to the beginning
                   @-P                #Paste this text "- times behind the cursor.

— James
fonte

Quantos bytes teriam sido se houvesse operadores matemáticos?

— Adnan

@ Adnan É difícil dizer, já que não sei exatamente como elas serão. Otimista eu diria cerca de 30 bytes?

— James

2

Vitsy, 43 bytes

IV2m3mz4m2m
3mV\D4m
V1+2/\[1m]
' || '
}}ZaO

Explicação:

IV2m3mz4m2m

I            Grab the length of the input string.
 V           Save that value to a global final variable.
  2m         Call the method at line index 2.
    3m       Call the method at line index 3.
      z      Push the entire input to the stack.
       4m    Call the method at line index 4.
         2m  Call the method at line index 2.

3mV\D4m

3m           Call the method at line index 3.
  V          Push the global variable to the stack.
   \D        Duplicate the top item on the stack that many times.
     4m      Call the method at line index 4.

V1+2/\[1m]

V            Push the global variable to the stack.
 1+          Add one to the top value.
             REASONING: We want ceil(V/2), and since repeat commands follow the floor value of repeats, we want ceil(V/2)+.5, so we add one to make this work right.
   2/        Divide by two.
     \[1m]   Call method 1 that top value of the stack times.

' || '

' || '       Push ' || ', the string, to the stack.

}}ZaO

}}           Push the bottom item of the stack to the top twice.
  Z          Output everything in the stack.
   aO        Output a newline.

Experimente online!

~~Observe que, devido a um erro no TIO, a entrada com caracteres unicode não funcionará. Você precisará usar a versão local em vez disso.~~ Obrigado, @Dennis!

— Addison Crump
fonte

1

Pyke, 31 bytes

"||
"1dQlO*:Ql_2f_*iO"|  |"2Q:i

Experimente aqui!

Obrigado @ R.Kap por salvar um byte com o truque de dividir o piso

— Azul
fonte

1

Ruby, 57 bytes

Usa truques de divisão inteira e tira proveito das peculiaridades da putsfunção Ruby .

->e{s=e.size+1;puts k=[?|+' '*-~s+?|]*(s/2),"| #{e} |",k}

— Value Ink
fonte

1

JavaScript ES6, 83 78 bytes

e=>(a=`| ${" ".repeat(n=e.length)} |
`.repeat(Math.ceil(n/2)))+`| ${e} |
${a}`

— Conor O'Brien
fonte

Você não precisa do f=, que economiza 2 bytes. Salve outros 2 bytes movendo-se edentro e afora do modelo . Salve outros 2 bytes inserindo espaços em vez de adicionar 2 à repetição. Salvar outro monte de bytes usando pouco mudando para dividir por 2.

— Neil

Eu não acho que isso funciona, ele só tenta imprimir o código-fonte da repetição

— Bálint

Tente novamente, eu o corrigi @ Bálint

— Conor O'Brien

1

> <> , 103 bytes

i:0(?\
}$&1[\~rl:::2%+*:2,
1-:?!\" "$
]{\  \~
?!\$}1-:
~&\
?!\l$:@-[l2)
~]\
}}\" || "
?!\ol
8.>]l?!;ao2

Experimente online!

Essa solução é baseada na observação de que cada linha consiste em | <x> |, onde <x>está o padrão na linha do meio e o mesmo número de espaços nas outras linhas.

Depois de ler a entrada (comprimento n) do STDIN, o programa abre n*(n+(n%2))espaços. A pilha é então rolada metade do número de vezes. Em seguida, todos os ncaracteres , exceto os são puxados para uma nova pilha, deixando uma pilha de pilhas que consiste em nespaços ou no próprio padrão (apenas na pilha do meio). Na etapa de saída, o conteúdo da pilha atual é impresso, cercado por |e |.

— Sok
fonte

1

C, 89 bytes

f;main(int c,char**a){for(c=strlen(*++a)+1;f<(c|1);)printf("|%*s |\n",c,f++==c/2?*a:"");}

Não tenho certeza se ele vai lidar com emoticons não-ascii embora ....

— aragaer
fonte

Você pode testá-lo com emoticons não ascii?

— Rɪᴋᴇʀ

Tentou e o resultado não foi bom - strlenconta os bytes até o primeiro zero byte e, como resultado, os emoticons não-ascii são considerados muito mais amplos do que são.

— Aragaer 20/05

1

PowerShell v3 +, 72 bytes

param($a)$b=("| "+(" "*($l=$a.length))+" |`n")*($l+1-shr1);"$b| $a |";$b

Leva a string de entrada $a. Constrói $bcomo (a cadeia vazia de extremidade de tubo (com $a.lengthespaços no meio) e uma nova linha à direita) repetida (comprimento + 1 mudou para a direita um bit, ou seja, dividido por dois e no teto) vezes. Em seguida, gera as cópias de $b, a sequência de entrada com seus próprios pipes e, finalmente, as cópias de $bnovo.

Requer v3 + para o -shroperador de troca de bits .

Exemplos

PS C:\Tools\Scripts\golfing> .\grow-a-treemote.ps1 '>:-|'
|      |
|      |
| >:-| |
|      |
|      |


PS C:\Tools\Scripts\golfing> .\grow-a-treemote.ps1 '>:`-('
|       |
|       |
|       |
| >:`-( |
|       |
|       |
|       |

— AdmBorkBork
fonte

1

Pitão, 30 bytes

Estou surpreso que uma tarefa tão fácil não seja implementada no Pyth.

Ls[K\|dbdK)j++J*/hlQ2]sym;QyQJ

Experimente online!

— Freira Furada
fonte

1

TSQL, 96 88 bytes

DECLARE @ varchar(100)='^_^'

PRINT STUFF(REPLICATE('|'+SPACE(2+LEN(@))+'|
',LEN(@)*2-1),LEN(@)*(LEN(@)+5)-3,LEN(@),@)

Experimente online!

— t-clausen.dk
fonte

Cresça um Treemote!

Desafio: dado o emoticon baseado em texto, produza o treemote correspondente.

Casos de teste:

05AB1E , 27 25 bytes

Python 3.5, 76 75 73 bytes:

Dyalog APL , 37 34 33 bytes

Casos de teste

V, 60 57 bytes

Vitsy, 43 bytes

Pyke, 31 bytes

Ruby, 57 bytes

JavaScript ES6, 83 78 bytes

> <> , 103 bytes

C, 89 bytes

PowerShell v3 +, 72 bytes

Exemplos

Pitão, 30 bytes

TSQL, 96 88 bytes