12

Questo è il mio amico Thomas. È mezzo albero, metà emoticon.

|    |
| :D |
|    |

È solo. Facciamolo degli amici!

Dato un emoticon testuale come input (ad esempio ಠ_ಠ, :P, >_>, non 😀, 🤓o 🐦), l'uscita treemote corrispondente.

La lunghezza di un treemote è quanti caratteri è lon (sostanzialmente la maggior parte delle funzioni di lunghezza incorporate per le stringhe). Quindi ಠ_ಠha lunghezza 3.

La sintassi per un treemote di lunghezza nè la seguente:

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

Quindi qualsiasi treemote di lunghezza 3 sembrerebbe:

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

Ha una ceil(n/2)nuova linea di segmenti di tronco separati su entrambi i lati, ciascuno con 2 + nspazi all'interno.

Sfida: vista l'emoticon testuale, genera il treemote corrispondente.

Altre regole:

Questo è code-golf , il che significa che voglio che tu scriva codice breve.
Scappatoie standard non consentite.
È necessario supportare caratteri non ascii a meno che la propria lingua non sia in grado di gestirli.

Casi test:

^_^

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

\o/

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


(✿◠‿◠)

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


D:

|    |
| D: |
|    |


( ͡° ͜ʖ ͡°)


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

code-golf ascii-art

— Rɪᴋᴇʀ
fonte

Sono consentite le nuove righe finali?

— R. Kap,

Partiamo dal presupposto che le emoticon 1 carattere non esistono?

— Adám,

Per "emoticon testuale" intendi emoticon ascii?

— Downgoat,

@Downgoat no. Vedi il ಠ_ಠcaso di test.

— Rɪᴋᴇʀ

6

Magari aggiungi un caso di prova con una lunghezza diversa da 3 ...

— SuperJedi224,

4

05AB1E , 27 25 byte

Codice:

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

Spiegazione:

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.

Utilizza la codifica CP-1252 . Provalo online! .

— Adnan
fonte

L'immissione ( ͡° ͜ʖ ͡°)restituisce risultati divertenti.

— Shaun Wild,

@ShaunWild Sì, è un caso di test strano, perché di per ( ͡° ͜ʖ ͡°)sé è lungo 11 caratteri, ma sembra lungo 8 caratteri.

— Adnan,

4

Python 3.5, 76 75 73 byte:

( Grazie a Blue per un suggerimento che ha salvato 2 byte! )

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

Provalo online! (Ideone)

Inoltre, ecco una versione Python 2.7.5 non competitiva poiché è molto più lunga a 87 byte .

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

Questo perché la codifica predefinita di Python 2 è ascii, e quindi, caratteri come al di ಠfuori dell'intervallo di 128 punti unicode contano come più di 1 byte ( list('ಠ')rese ['\xe0', '\xb2', '\xa0']). L'unica soluzione che mi è venuta in mente per questo è stata prima di decodificare l'input usando utf-8, quindi passare a questa utf-8stringa decodificata.

Prova questa versione di Python 2 online! (Ideone)

— R. Kap
fonte

Puoi eliminare le parentesi intorno (- (- q // 2)) per 2 byte. Penso che puoi salvare altri 2 byte passando a Python 2.7. Non è necessario il secondo / in // e solo uno spazio nell'istruzione print.

— Blue,

@Blue Sì, hai ragione, posso rimuovere quella seconda coppia di parentesi. Tuttavia, ho non serve il secondo /in //per fare il ceil divisione.

— R. Kap,

come stavo dicendo, in Python 2.7 la divisione dei numeri interi viene eseguita con 1 /

— Blue

@Blue Oh, immaginavo che stavi dicendo che non ne ho bisogno in Python 3. Bene, in tal caso, passerò a Python 2. Grazie per i suggerimenti! :)

— R. Kap,

@Blue In tal caso, come si fa a dividere il float in Python 2?

— R. Kap,

3

Dyalog APL , 37 34 33 byte

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

Utenti Chrome: vedi nota a piè di pagina *

Casi 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 visualizza erroneamente i due caratteri ≢⍵(U + 2262, U + 2375) come ≢⍵(U + 2261, U + 0338, U + 2375) anziché come ̸≡⍵(U + 0338, U + 2262, U + 2375), quindi ecco un mostra la versione per Chrome:{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×̸̸≡⍵}}

— Adamo
fonte

1

+1 per avere emoticon nel codice stesso {⍺⍵⍺} ¨b

— Value Ink,

3

Ah, {⍺⍵⍺}¨bè l'emoticon del "programmatore APL sulla sua quinta tazza di caffè che dà un pollice in su".

— Lynn,

2

V, 60 57 byte

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

Sfortunatamente, V non ha quasi nulla in termini di operazioni matematiche. Le funzioni divide e ceil hanno gonfiato drasticamente il conteggio dei byte.

Poiché questo contiene un mucchio di cattivi non stampabili, ecco un hexdump reversibile:

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

Spiegazione:

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.

— Giacomo
fonte

Quanti byte sarebbe stato se ci fossero operatori matematici?

— Adnan,

@Adnan È difficile dirlo, dal momento che non so esattamente come saranno. Ottimisticamente direi circa 30 byte?

— James,

2

Vitsy, 43 byte

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

Spiegazione:

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.

Provalo online!

~~Si noti che, a causa di un bug in TIO, l'input con caratteri unicode non funzionerà. Dovrai usare la versione locale invece per quelli.~~ Grazie @Dennis!

— Addison Crump
fonte

1

Pyke, 31 byte

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

Provalo qui!

Grazie @ R.Kap per aver salvato un byte con il trucco di divisione del piano

— Blu
fonte

1

Rubino, 57 byte

Usa trucchi di divisione interi e sfrutta le stranezze nella putsfunzione di Ruby .

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

— Value Ink
fonte

1

JavaScript ES6, 83 78 byte

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

— Conor O'Brien
fonte

Non è necessario il f=, che consente di risparmiare 2 byte. Salvare altri 2 byte spostandosi eall'interno del modello e aall'esterno. Salvare altri 2 byte inserendo spazi anziché aggiungendo 2 alla ripetizione. Salvare un altro gruppo di byte usando lo spostamento dei bit per dividere per 2.

— Neil

Non penso che funzioni, cerca solo di stampare il codice sorgente della ripetizione

— Bálint,

Riprova, l'ho risolto @ Bálint

— Conor O'Brien,

1

> <> , 103 byte

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

Provalo online!

Questa soluzione si basa sull'osservazione di ciascuna linea | <x> |, dov'è <x>lo schema nella linea di mezzo e lo stesso numero di spazi nelle altre linee.

Dopo aver letto l'input (lunghezza n) da STDIN, il programma sposta gli n*(n+(n%2))spazi. Lo stack viene quindi lanciato la metà delle volte. Successivamente, tutti i npersonaggi tranne quelli vengono tirati in una nuova pila, lasciando una pila di pile costituita da nspazi o dal modello stesso (solo nella pila centrale). Nella fase di output, i contenuti dello stack corrente vengono stampati, circondati da |e |.

— Sok
fonte

1

C, 89 byte

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

Non sono sicuro se gestirà emoticon non ascii però ...

— aragaer
fonte

Puoi provarlo con le emoticon non ascii?

— Rɪᴋᴇʀ

Provato e il risultato non era buono - strlenconta i byte fino al primo zero zero e di conseguenza le emoticon non ascii sono considerate molto più ampie di loro.

— Aragaer,

1

PowerShell v3 +, 72 byte

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

Accetta la stringa di input $a. Costruisce $bcome (la stringa vuota con $a.lengthestremità del tubo (con spazi nel mezzo) e una nuova riga finale) ripetuta (lunghezza + 1 spostata a destra di un bit, vale a dire, divisa per due e soffitto) volte. Quindi genera le copie di $b, la stringa di input con le proprie pipe e infine le copie di $bnuovo.

Richiede v3 + per l' -shroperatore bit-shift .

Esempi

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


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

— AdmBorkBork
fonte

1

Pyth, 30 byte

Sono sorpreso che un compito così semplice non sia implementato in Pyth.

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

Provalo online!

— Perdente Suora
fonte

1

TSQL, 96 88 byte

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

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

Prova online!

— t-clausen.dk
fonte

Fai crescere un Treemote!

Sfida: vista l'emoticon testuale, genera il treemote corrispondente.

Casi test:

05AB1E , 27 25 byte

Python 3.5, 76 75 73 byte:

Dyalog APL , 37 34 33 byte

Casi test

V, 60 57 byte

Vitsy, 43 byte

Pyke, 31 byte

Rubino, 57 byte

JavaScript ES6, 83 78 byte

> <> , 103 byte

C, 89 byte

PowerShell v3 +, 72 byte

Esempi

Pyth, 30 byte

TSQL, 96 88 byte