Centra il testo!

40

Centra il testo!

In questa sfida dovrai centrare varie linee.

Esempi

Foo
barbaz

 Foo
barbaz

Hello
World

Hello
World

Programming Puzzles
&
Code Golf

Programming Puzzles
         &
     Code Golf

specificazioni

Ogni riga di input avrà sempre almeno un carattere non di spazi bianchi, puoi supporre che l'unico carattere di spazi bianchi siano spazi ( ) e righe. Ogni riga di input non avrà spazi vuoti finali e / o iniziali (ad eccezione della nuova riga). Lo spazio bianco finale nell'output non è consentito.

Dovresti centrare la linea più lunga nell'input. Se quella linea è anche lunga, il tuo programma / funzione dovrebbe preferire centrare a sinistra. La lunghezza massima della linea è qualunque sia la tua lingua in grado di gestire, ma il tuo programma dovrebbe funzionare su linee di almeno 500 di lunghezza.

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

Questo è code-golf, quindi vince il codice più breve in byte!

code-golf  string  typography 
— Downgoat
fonte
Non ci sarà mai più di uno spazio interno?
— cat
@cat non ci sarà mai alcuna spazi iniziali o spazio bianco in coda su una linea (si aspetta per il ritorno a capo, se ce n'è uno)
— Downgoat
sì, ma intendo spazi interni , come, tra le parole
— cat
1
@cat oh, tra le parole potrebbe esserci più di uno spazio bianco. Ad esempio foo(space)(space)(space)barè un input perfettamente accettabile
— Downgoat
possiamo supporre che ci sarà sempre più di 1 riga?
— GamrCorps il

Risposte:

15

Pyth, 19 17 byte

2 byte grazie a Jakube

V.ztr+1.[l.T.zNd6

Dimostrazione

Penso che questa sia la prima volta che la funzione del pad centrale .[è stata utile. La lunghezza della linea più lunga viene trovata utilizzando transpose ( .T) non troncante .

Gli spazi finali vengono rimossi aggiungendo un carattere non spaziale nella parte anteriore, eliminando gli spazi, quindi rimuovendo il carattere aggiunto.

— isaacg
fonte
1
Probabilmente abbiamo bisogno di una lunghezza massima nell'array. Viene troppo spesso. +1
— Maltysen,
Le specifiche dicono che "Non è consentito il trascinamento di spazi bianchi nell'output". Questo sembra avere spazi vuoti finali su ogni linea breve nell'output, quindi non sono sicuro che conti.
— Patata,
@potato Grazie - è stato aggiunto da quando ho risposto.
— Isaacg,
31

vim, 43 36 35 byte

VGrx:sor
G:let &tw=col("$")
uu:%ce

Troppo bello per non pubblicare. Nota la nuova riga finale; è significativo.

Grazie a @Marth per aver salvato un personaggio!

formato compatibile con vim:

VGrx:sor<cr>G:let &tw=col("$")<cr>uu:%ce<cr>

Spiegazione:

VGrx                   replace every character with an "x"
:sor<cr>               sort (since all chars are now same, sorts by line length)
G                      go to the very last line
:let &tw=col("$")<cr>  set &tw to column number of last char on this line
                         "let &tw" is equivalent to "set tw"
                         tw is short for textwidth, used in :center
uu                     undo the sort, and the replacing-with-x too
:%ce<cr>               center over entire file (%), using textwidth set earlier
— Maniglia
fonte
1
Sicuramente questo dovrebbe essere fatto in modalità Inserisci, giusto?
— Alex A.
9
@AlexA. Niente di tutto ciò viene fatto in modalità inserimento. ಠ_ಠ
— Maniglia della porta
Se si utilizza sor!per invertire l'ordinamento, è possibile utilizzare col("$")per ottenere la lunghezza della prima riga (ora la più lunga da quando l'ordine è invertito) invece di utilizzare G$, risparmiando un totale complessivo di 1 byte! modifica : oppure è possibile mantenere l'ordinamento e utilizzare G:let &tw=col("$")invece.
— Marth,
@Marth Grazie! Ho scelto quest'ultimo (senza un motivo particolare).
— Maniglia della porta
Guardando :h :sortho appena scoperto che puoi passare una regex per saltare il testo corrispondente nell'ordinamento, in modo da poter utilizzare :sor /./per ordinare in lunghezza (+4 byte), che ti consente di rimuovere VGrx(-4 byte) e il secondo annullamento ( -1 byte). Puoi anche usare i |separatori invece di <cr>concatenare i comandi, il che ti consente di saltare il :precedente let(-1 byte) (nota che allora devi usare la sor!soluzione, Gnon è un comando ex). Quindi :sor! /./|let &tw=col("$")|u|%ce (con un trailing <CR>) dovrebbe salvare 2 byte.
— Marth,
23

Mathematica, 96 byte

StringRiffle[#~StringPadLeft~Floor[Max@(l=StringLength)@a/2+l@#/2]&/@(a=#~StringSplit~"
"),"
"]&

Non chiedermi come ha funzionato, ho solo armeggiato con esso fino a quando non ha prodotto l'output corretto.

— LegionMammal978
fonte
27
+1 per "Non chiedermi come ha funzionato, ho appena armeggiato con esso fino a quando non ha prodotto l'output corretto"
— cat
4
@cat Ecco come faccio a giocare a golf.
— lirtosiast,
11

Funciton , non competitivo

Questa sfida ha evidenziato la mancanza dolorosa di una funzione di "valore massimo" (e valore minimo) per le sequenze pigre, quindi ... le ho aggiunte alla libreria principale (si chiamano rispettivamente ⊤ e ⊥). Pertanto non mi sono preso la briga di inviarlo come risposta golfizzata (dovrebbe includere la dichiarazione di funzione to per essere valida), quindi ecco solo il programma principale.

Eseguire (function(){$('pre,code').css({lineHeight:5/4,fontFamily:'DejaVu Sans Mono'});})()nella console del browser per ottenere un rendering più gradevole.

   ╓───╖         ╔════╗  ┌───╖  ╔═══╗
 ┌─╢ ‡ ╟─┐       ║ 10 ╟──┤ ǁ ╟──╢   ║
 │ ╙───╜ │       ╚════╝  ╘═╤═╝  ╚═══╝
 │ ┌───╖ │  ┌──────────────┴──────────────────┐
 └─┤ ‼ ╟─┘┌─┴─╖ ┌───╖ ┌───╖ ┌───╖ ┌───╖       │     │
   ╘═╤═╝  │ ɱ ╟─┤ ⊤ ╟─┤ + ╟─┤ ~ ╟─┤ ℓ ╟───┐ ┌─┴─╖ ┌─┴─╖ ╔════╗
     │    ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╘═══╝ ╘═══╝   │ │ ɱ ╟─┤ ʝ ╟─╢ 10 ║
    ┌───╖ ╔═╧═╕ ╔═══╗ ┌─┴──╖ ┌───╖ ╔════╗ │ ╘═╤═╝ ╘═══╝ ╚════╝
  ┌─┤ ℓ ╟─╢   ├─╢ 1 ║ │ >> ╟─┤ … ╟─╢ 32 ║ │   │
  │ ╘═══╝ ╚═╤═╛ ╚═╤═╝ ╘═╤══╝ ╘═╤═╝ ╚════╝ │ ╔═╧═╕ ╔═══╗
  └─────────┘     └─────┘      │   ┌───╖  ├─╢   ├─╢ 0 ║
                               └───┤ ‡ ╟──┘ ╚═╤═╛ ╚═══╝
                                   ╘═╤═╝      │
                                     └────────┘

Spiegazione

Credo che questa sia la prima risposta di Funciton su questo sito che utilizza espressioni lambda.

  • In primo luogo, usiamo ǁper dividere la stringa di input nelle newline (ASCII 10). Questo restituisce una sequenza pigra.
  • Passiamo quella sequenza attraverso ɱ(mappa), dandogli una lambda che calcola la lunghezza di ogni stringa, quindi passiamo attraverso la sequenza finale ⊤per ottenere la lunghezza della linea più lunga.
  • Passiamo anche quella sequenza attraverso un'altra ɱ, dandole una lambda che calcola la lunghezza di ogni stringa, la sottrae dalla lunghezza massima della linea calcolata in precedenza, divide quella per 2 (in realtà shift-destra 1), genera così tanti spazi (ASCII 32) e quindi concatena la stringa in quegli spazi. (Per motivi geometrici, ho dichiarato una ‡funzione che chiama ‼(stringa concatenata) con i parametri invertiti.)
  • Infine, usiamo ʝper rimettere insieme tutte le stringhe, usando newline (ASCII 10) come separatore.
— Timwi
fonte
+1 per quanto sia fantastico e "Sono 716 caratteri, per un totale di 1.508 byte"
— cat
9

Retina , 54 52 byte

+m`^(.)+$(?<=(?=[^\t]*^..(?<-1>.)+(?(1)^))[^\t]*)
 $0

Le \ts possono essere sostituite con schede effettive, ma le ho usate \tqui, altrimenti SE convertirà le schede in spazi. Si noti che c'è uno spazio iniziale sulla seconda riga.

Provalo online.

Spiegazione

L'idea di base è quella di abbinare una linea che sia almeno due caratteri più corta della linea più lunga (o tecnicamente, due caratteri più corti di qualsiasi altra linea) e circondarla in due spazi. Questo si ripete fino a quando non riusciamo più a trovare una tale linea, il che significa che tutte le linee sono all'interno di un carattere della lunghezza massima (in cui l'unico carattere deve tenere conto delle discrepanze di parità e garantisce che queste linee siano spostate a sinistra- centro).

Per quanto riguarda l'attuale regex:

^(.)+$

Abbina solo una riga mentre si spinge una cattura sul gruppo 1per ciascun personaggio.

(?<=...[^\t]*)

È un lookbehind che viene abbinato da destra a sinistra e sposta il cursore all'inizio della stringa, in modo che il lookahead all'interno possa controllare l'intera stringa. Si noti che a causa della mancanza di un'ancora, il lookahead potrebbe essere applicato da qualsiasi altra parte, ma ciò non crea ulteriori corrispondenze. Sappiamo che [^\t]corrisponderà sempre a qualsiasi carattere della stringa, poiché è garantito che l'input contenga solo spazi e avanzamenti di riga per quanto riguarda gli spazi bianchi.

(?=[^\t]*^..(?<-1>.)+(?(1)^))

Questo lookahead cerca di trovare una linea che sia almeno due caratteri più lunga di quella che stiamo attualmente abbinando. [^\t]*si sposta attraverso la stringa per poter abbinare qualsiasi linea. ^assicura che stiamo iniziando dall'inizio della linea. ..quindi corrisponde ai due caratteri aggiuntivi richiesti per la riga più lunga. Ora (?<-1>.)+abbina i singoli caratteri in quella riga mentre si estrae dal gruppo 1(nota che .non può corrispondere a un avanzamento di riga, quindi questo è vincolato a una riga). Infine, (?(1)^)afferma che siamo riusciti a svuotare l'intero gruppo 1. Se la linea è più corta del necessario, ciò non è possibile, poiché non ci sono abbastanza caratteri nella linea per essere pop dal gruppo 1 abbastanza spesso per svuotarla.

— Martin Ender
fonte
7

Jolf , 3 byte

Non competitiva, aggiorna la domanda postdatate.

Provalo qui! .

pci
pc  center
  i  string input

¯ \ _ (ツ) _ / ¯ Ho pensato che sarebbe stata una funzione utile.

— Conor O'Brien
fonte
1
Questa è una scappatoia standard, e sebbene non esplicitamente vietata, la sua cattiva forma a meno che non sia integrata in una lingua che trovi, non in una che crei.
— Elias Benevedes,
3
@EliasBenevedes Ho aggiunto la funzione prima del concorso. Non aggiorno spesso il mio codice fino a quando non diventa relavent.
— Conor O'Brien,
7

JavaScript (ES6), 93 91 byte

s=>(m=l=s.split`
`).map(x=>(v=x.length/2)<m?v:m=v).map((x,i)=>" ".repeat(m-x)+l[i]).join`
`

2 byte salvati grazie a @ edc65 !

Spiegazione

s=>(
  m=                // m = max line length (divided by 2)
    l=s.split`
`)                  // l = array of lines
.map(x=>            // for each line
  (v=x.length/2)    // v = current line length / 2
    <m?v:m=v        // set m to the max line length and return v
)
.map((x,i)=>        // for each line length / 2
  " ".repeat(m-x)   // add spaces before
    +l[i]           // add line text
)
.join`
`                   // return lines as a newline-separated string

Test

Mostra snippet di codice

— user81655
fonte
.repeataccetta e tronca valori non interi, quindi non è necessario|0
— edc65
7

CJam, 26 23 19 byte

qN/_z,f{1$,m2/S*\N}

La mia prima volta che utilizzo CJam! Quattro byte salvati grazie a Martin Büttner.Provalo online.

Spiegazione

qN/    e# Read input and split each line
_z,    e# Transpose a copy and get its length to find the longest line
f{     e# For each line...
  1$,- e# Subtract its length from the longest length
  2/   e# Divide by two to get just the spaces to add to the left
  S*\  e# Add a string with that many spaces to the beginning
  N    e# Add a newline to go on to the next line
}
— NinjaBearMonkey
fonte
1
Ecco alcuni suggerimenti :)qN/_z,f{1$,m2/S*\N}
— Martin Ender il
6

LabVIEW, 3 o 35 LabVIEW Primitives

Trova le linee fino a quando non ne rimangono più, quindi calcola quanti spazi aggiungere e mette tutto insieme.

In alternativa, puoi usare l'allineamento centrale incorporato sugli indicatori di stringa, ma in qualche modo ti sembra di barare.

— Eumel
fonte
6

Python 2, 83 81 byte

def f(s):
 t=s.split('\n')
 for y in t:print(max(len(f)for f in t)-len(y))/2*' '+y

Grazie a @xnor per aver salvato 2 caratteri

esempio di input:

f("""Programming Puzzles
&
Code Golf""")

esempio di output:

Programming Puzzles
         &
     Code Golf

E termina al secondo posto con 84 byte usando str.center () e str.rstrip (grazie @JF).

def f(s):
 t=s.split('\n')
 for y in t:print y.center(max(len(f)for f in t)).rstrip()
— Willem
fonte
Non salva i caratteri da assegnare lena una variabile che usi due volte, che si interrompe anche a 5 caratteri (come range). Inoltre, è possibile utilizzare mapper l'elenco comp.
— xnor
@Willem, potresti usare str.rstrip()dopo aver chiamato centerper sbarazzarti dello spazio finale.
— JF
Puoi salvare 7 byte con un programma completo e usando len(max(a,key=len)), vedi questo .
— ბიმო
5

TeaScript , 24 byte

£p.R((aßln)¯-ln)/2)+l,§)

Passa attraverso le linee, aggiunge floor((max line length - line length) / 2)spazi all'inizio.

Ungolfed

£   p.R((aß  ln)¯  -ln)/2)+l,§   )
xl(#p.R((am(#ln)X()-ln)/2)+l,`\n`)

xl(#    // Loops through newlines
    p.R(   // Repeats spaces
      (
       am(#ln)    // Map all line lengths
              X() // Get largest line length
       -ln)       // Subtract current line length
      /2)  // Divide by two
      +l,  // Add current line text
`\n`)

Provalo online

— Downgoat
fonte
5
Perché le mie risposte continuano ad essere Downgoated? Penso che sia il momento di cambiare il nome utente / avatar: p
— Downgoat
Risolto dal 27/07/2016. : P
— user48538,
5

PowerShell, 58 67 byte

fino a 58 byte grazie ai commenti di @ mazzy:

param($a)$a|%{$_|% *ft(($a|% le*|sort)[-1]/2+$_.length/2)}


# It takes an array of strings as input
PS C:\Temp> .\center.ps1 'aaa','bb','c'
aaa
bb
 c


# Or here, read from a file
PS C:\Temp> .\center.ps1 (gc t.txt)
info0:info1:info2:info3
      info0:info1
          ttt
          tt
           t
  • Prende una serie di stringhe come $a, scorre sopra ogni stringa con|%{...} .
  • chiama il string.padleft()metodo su ogni stringa, tramite% -member collegamento, che utilizza come parametro la lunghezza finale della linea desiderata.
    • abbiamo bisogno array_longest_line_length/2 + current_line_length/2
    • la parte finale è current_line_length/2->$_.length/2
    • l'altra parte sta ricalcolando la lunghezza massima della linea dell'array ogni volta attraverso il ciclo, e lo fa con un ciclo nidificato che crea una matrice di lunghezze di linea, ordinando quella, quindi accetta l'ultima.
— TessellatingHeckler
fonte
— mazzy
1
@mazzy è meglio! dal momento che non hai pubblicato come risposta, l'ho modificato nella mia risposta con credito.
— Tessellating Heckler,
3

Emacs Lisp, 203 byte

(let((f 0)(l 0))(dolist(s(split-string(buffer-string)"\n"))(set'l(string-width s))(when(> l f)(set'f l)))(let((fill-column f))(goto-char(point-min))(while(<(point)(point-max))(center-line)(next-line)))))

Ungolfed:

(let ((f 0) (l 0))
  (dolist (s (split-string(buffer-string) "\n"))
    (set 'l (string-width s))
    (when (> l f)
      (set 'f l)))
    (let ((fill-column f))
      (goto-char (point-min))
      (while (< (point) (point-max))
        (center-line)
        (next-line)))))

centrato:

               (let ((f 0) (l 0))
 (dolist (s (split-string(buffer-string) "\n"))
           (set 'l (string-width s))
                 (when (> l f)
                  (set 'f l)))
             (let ((fill-column f))
            (goto-char (point-min))
         (while (< (point) (point-max))
                 (center-line)
                (next-line)))))
— Lord Yuuma
fonte
3

HTML, 40 byte

<xmp style=float:left;text-align:center>

Mostra snippet di codice

Lo snippet include il </xmp>tag perché il visualizzatore dello snippet di codice desidera che i miei tag siano bilanciati.

— Neil
fonte
2

MATL , 22 31 byte

`jtYz~]xXhc4X4H$ZuZ{Zv

Ogni riga viene inserita con una riga finale (ovvero una entersequenza di tasti). Una linea vuota (dueenter sequenze di tasti) segna la fine dell'input.

Esempio

>> matl `jtYz~]xXhc4X4H$ZuZ{Zv
> foo
> barbaz
> 
 foo
barbaz

Spiegazione

`          % do...
  j        % input one string
  tYz~     % is it not empty?
]          % ...while
x          % delete last input (empty string)
Xh         % concatenate all inputs into a cell array
c          % convert to char (2D array). This fills with spaces to the right
4X4H$Zu    % center justify
Z{         % convert to cell array of strings
Zv         % remove trailing blanks of each string
— Luis Mendo
fonte
2

Rubino, 76 68 61 byte

->t{(s=t.split$/).map{|l|l.center(s.map(&:size).max).rstrip}}

Esecuzione di esempio:

2.1.5 :001 > puts ->t{(s=t.split$/).map{|l|l.center(s.map(&:size).max).rstrip}}["Programming Puzzles\n&\nCode Golf"]
Programming Puzzles
         &
     Code Golf
— uomo al lavoro
fonte
53 byte:->t{(s=t.split$/).map{|l|l.center s.map(&:size).max}}
— daniero il
Ho anche tentato centerprima di tutto, ma a quanto ho capito, che da solo avrebbe infranto la regola "Non è consentito lo spazio bianco finale nell'output". Grazie per la &:sizeparte - ci ho provato anche io, ma ho sicuramente sbattuto qualcosa intorno alla sintassi.
— arte
2

Haskell, 111 81 77 byte

l=length
f s|q<-lines s=unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q]

Input per la funzione f, l'output non viene stampato.

Uso: carica nell'interprete ghci center.hse poi se vuoi stampare l'output di f su una data stringaputStr$f"Programming Puzzles\n&\nCode Golf"

Modifica: grazie a nimi per 34 byte, ottimo lavoro! : D

— Basile-henry
fonte
Ancora due cose: L'ultima versione del Preludio include una versione di infisso map: <$>. replicate(...)' 'può essere sostituito da [1.. ...]>>" ". Tutto sommato: unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q].
— nimi,
Ah sì, ricordo che hai menzionato la nuova infissione della mappa in una precedente presentazione che ho fatto. Come funziona il trucco replicato?
— basile-henry,
l1 >> l2crea (lunghezza l1) copie di l2 e le concatena. Ad esempio "abcd" >> [1,2]-> [1,2,1,2,1,2,1,2](<- 4 copie di 1,2 in un unico elenco). Nel nostro caso è [1..n]>>" "che è n copie di uno spazio che è lo stesso di ciò che replicatefa.
— nimi,
Bello, grazie per la spiegazione! :)
— basile-henry il
2

R, 126 byte

codice

for(z in 1){l=scan(,"");m=sapply(l,nchar);t=max(m[m==max(m)]);for(i in 1:length(m))cat(rep(" ",(t-m[i])/2),l[i],"\n", sep="")}

ungolfed

for(z in 1){                          # any way to get rid of this?
  l=scan(,"")
  m <- sapply(l,nchar)
  t <- max(m[m==max(m)])
  for(i in 1:length(m)){
    cat(rep(" ",(t-m[i])/2),l[i],"\n", sep="")
  }
}

Probabilmente ci sono modi migliori per farlo, ancora lavorando su di esso.

— Mutador
fonte
1

Gema, 160 byte

\L<T>=@push{i;$0}@set{m;@cmpn{@length{$0};${m;};$m;$m;@length{$0}}}
?=
\Z=@repeat{@sub{@line;1};@set{o;@right{@div{@add{$m;@length{$i}};2};$i}\n${o;}}@pop{i}}$o

Scritto principalmente per la mia curiosità di vedere cosa si può fare in una lingua senza un'adeguata struttura di array e istruzioni di loop adeguate.

Esecuzione di esempio:

bash-4.3$ gema '\L<T>=@push{i;$0}@set{m;@cmpn{@length{$0};${m;};$m;$m;@length{$0}}};?=;\Z=@repeat{@sub{@line;1};@set{o;@right{@div{@add{$m;@length{$i}};2};$i}\n${o;}}@pop{i}}$o' <<< $'Programming Puzzles\n&\nCode Golf'
Programming Puzzles
         &
     Code Golf
— uomo al lavoro
fonte
1

Perl 6 , 61 byte

$/=(my@l=lines)».chars.max;for @l {put ' 'x($/-.chars)/2~$_} # 61 bytes

utilizzo: 

$ perl6 -e '$/=(my@l=lines)».chars.max;for @l {put " "x($/-.chars)/2~$_}' <<< \
'Programming Puzzles
&
Code Golf'
Programming Puzzles
         &
     Code Golf
— Brad Gilbert b2gills
fonte
Perl 5 ti permetterebbe di eliminare gli spazi in cose come for @l {, radendo 2 byte, e di cambiarlo put " "in put" ", radendo un altro byte. È vero per Perl 6? (Non conosco Perl 6.) Inoltre, l'output visualizzato qui non corrisponde all'output richiesto; è un errore di battitura?
— msh210,
@ msh210 Perl 6 è un po 'più restrittivo con la sua sintassi. Più che compensato in altre aree però.
— Brad Gilbert b2gills il
1

Japt, 28 25

¡V=VwXl}R;¡Sp½*(V-Xl¹+X}R

Provalo online!

Come funziona

¡     V=VwXl}R;¡     Sp½*(V-Xl¹ +X}R
UmXYZ{V=VwXl}R;UmXYZ{Sp½*(V-Xl) +X}R

           // Implicit: U = input string, V = 0
UmXYZ{  }  // Map each item X in U through this function,
         R // splitting U at newlines beforehand:
  V=VwXl   //  Set V to max(X, Y.length).
           // V is now set to the length of the longest line.

UmXYZ{  }  // Map each item X in U with this function,
         R // again splitting U at newlines beforehand:
 ½*(V-Xl)  //  Take V minus X.length, and multiply by 1/2.
Sp         //  Repeat a space that many times.
        +X //  Concatenate X to the end.
— ETHproductions
fonte
0

PHP , 98 byte

function($s){foreach($a=explode("
",$s)as$l)echo str_pad($l,max(array_map(strlen,$a)),' ',2),"
";}

Provalo online!

Ungolfed:

function str_center( $s ) {
    $a = explode( PHP_EOL, $s );
    $m = max( array_map( 'strlen', $a ) );
    foreach( $a as $l ) {
        echo str_pad( $l, $m, ' ', STR_PAD_BOTH ), PHP_EOL;
    }
}

Produzione:

Programming Puzzles
         &         
     Code Golf
— 640KB
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.