Voici mon ami Thomas. Il est mi-arbre, mi-émoticône.

|    |
| :D |
|    |

Il est seul. Faisons-lui des amis!

Étant donné un émoticône basé sur du texte en entrée (par exemple ಠ_ಠ, :P, >_>et non pas 😀, 🤓ou 🐦), la sortie treemote correspondant.

La longueur d'un treemote est le nombre de caractères qu'il contient (essentiellement la plupart des fonctions de longueur intégrées pour les chaînes). A donc la ಠ_ಠlongueur 3.

La syntaxe d'un treemote de longueur nest la suivante:

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

Ainsi, tout treemote de longueur 3 ressemblerait à:

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

Il a ceil(n/2)des segments de tronc séparés par une nouvelle ligne de chaque côté, chacun avec des 2 + nespaces à l'intérieur.

Défi: compte tenu de l'émoticône textuelle, affichez le treemote correspondant.

Autres règles:

• Il s'agit de code-golf , ce qui signifie que je veux que vous écriviez du code court.
• Failles standard interdites.
• Vous devez prendre en charge les caractères non ascii à moins que votre langue ne puisse pas les gérer.

Cas de test:

^_^

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

\o/

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


(✿◠‿◠)

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


D:

|    |
| D: |
|    |


( ͡° ͜ʖ ͡°)


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

05AB1E , 27 25 octets

Code:

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

Explication:

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.

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Python 3.5, 76 75 73 octets:

( Merci à Blue pour une astuce qui a permis d'économiser 2 octets! )

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

Essayez-le en ligne! (Ideone)

En outre, voici une version Python 2.7.5 non concurrente car elle est beaucoup plus longue à 87 octets .

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

Cela est dû au fait que l'encodage par défaut de Python 2 est ascii, et par conséquent, que les caractères comme en ಠdehors de la plage de 128 points unicode comptent pour plus de 1 octet ( list('ಠ')donne ['\xe0', '\xb2', '\xa0']). La seule solution de contournement à laquelle je pouvais penser était de décoder d'abord l'entrée en utilisant utf-8, puis de passer à cette utf-8chaîne décodée.

Essayez cette version de Python 2 en ligne! (Ideone)

Dyalog APL , 37 34 33 octets

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

Utilisateurs de Chrome: voir note de bas de page *

Cas de test

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

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

* ^{Chrome affiche mal les deux caractères ≢⍵(U + 2262, U + 2375) en tant que ≢⍵(U + 2261, U + 0338, U + 2375) au lieu de ̸≡⍵(U + 0338, U + 2262, U + 2375), voici donc un version d'affichage pour Chrome:{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×̸̸≡⍵}}

V, 60 57 octets

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

Malheureusement, V n'a presque rien en termes d'opérations mathématiques. Les fonctions de division et de plafond ont considérablement gonflé le nombre d'octets.

Puisqu'il contient un tas de méchants non imprimables, voici un hexdump réversible:

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

Explication:

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.

Vitsy, 43 octets

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

Explication:

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.

Essayez-le en ligne!

Notez qu'en raison d'un bogue dans TIO, la saisie avec des caractères unicode ne fonctionnera pas. Vous devrez utiliser la version locale à la place pour ceux-ci. Merci, @Dennis!

Pyke, 31 octets

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

Essayez-le ici!

Merci @ R.Kap pour avoir sauvé un octet avec l'astuce de division du plancher

Rubis, 57 octets

Utilise des astuces de division entières et tire parti des caprices de la putsfonction de Ruby .

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

JavaScript ES6, 83 78 octets

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

> <> , 103 octets

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

Essayez-le en ligne!

Cette solution est basée sur l'observation de chaque ligne | <x> |, où se <x>trouve le motif sur la ligne médiane et le même nombre d'espaces dans les autres lignes.

Après avoir lu l'entrée (longueur n) de STDIN, le programme pousse les n*(n+(n%2))espaces. La pile est ensuite roulée deux fois moins de fois. Ensuite, tous les npersonnages sauf les personnages sont tirés vers une nouvelle pile, laissant une pile de piles composée soit d' nespaces, soit du motif lui-même (dans la pile du milieu uniquement). Dans l'étape de sortie, le contenu de la pile actuelle est imprimé, entouré de |et |.

C, 89 octets

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

Je ne sais pas si elle gérera les émoticônes non-ascii ...

PowerShell v3 +, 72 octets

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

Prend la chaîne d'entrée $a. Construit $bcomme (la chaîne vide terminée par un tuyau (avec des $a.lengthespaces au milieu) et une nouvelle ligne de fin) répétée (longueur + 1 décalée d'un bit vers la droite, c'est-à-dire divisée par deux et plafonnée) fois. Sort ensuite les copies de $b, la chaîne d'entrée avec ses propres canaux, et enfin les copies de $bnouveau.

Nécessite v3 + pour l' -shropérateur de décalage de bit .

Exemples

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


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

Pyth, 30 octets

Je suis surpris qu'une tâche aussi simple ne soit pas implémentée en Pyth.

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

Essayez-le en ligne!

TSQL, 96 88 octets

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

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

Essayez en ligne!