Centrar el texto!

40

Centrar el texto!

En este desafío, centrarás varias líneas.

Ejemplos

Foo
barbaz

 Foo
barbaz

Hello
World

Hello
World

Programming Puzzles
&
Code Golf

Programming Puzzles
         &
     Code Golf

Presupuesto

Cada línea de entrada siempre tendrá al menos un carácter que no sea un espacio en blanco, puede suponer que el único carácter de espacio en blanco son los espacios ( ) y las nuevas líneas. Cada línea de entrada no tendrá espacios en blanco al final o al final (excepto la nueva línea). El espacio en blanco al final de la salida no está permitido.

Debería centrarse entre la línea más larga de la entrada. Si esa línea tiene una longitud uniforme, su programa / función debería preferir centrarse a la izquierda. La longitud máxima de la línea es lo que su lenguaje pueda manejar, pero su programa debería funcionar en líneas de al menos 500 de longitud.

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Mostrar fragmento de código

Este es el código de golf, ¡el código más corto en bytes gana!

code-golf  string  typography 
— Downgoat
fuente
¿Nunca habrá más de un espacio interior?
— gato
@cat nunca habrá ninguna espacios en blanco, o con espacios en blanco en una línea (esperar para la línea, si lo hay)
— Downgoat
sí, pero me refiero a espacios internos , como, entre palabras
— gato
1
@cat oh, entre palabras puede haber más de un espacio en blanco. Por ejemplo, foo(space)(space)(space)bares una entrada perfectamente aceptable
— Downgoat
¿podemos suponer que siempre habrá más de 1 línea?
— GamrCorps

Respuestas:

15

Pyth, 19 17 bytes

2 bytes gracias a Jakube

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

Demostración

Creo que esta es la primera vez que la función de pad central .[es útil. La longitud de la línea más larga se encuentra utilizando transposición no truncada ( .T).

Los espacios finales se eliminan agregando un carácter que no sea espacio al frente, eliminando espacios y luego eliminando el carácter agregado.

— isaacg
fuente
1
Probablemente necesitemos una longitud máxima en la matriz. Viene con demasiada frecuencia. +1
— Maltysen
Las especificaciones dicen que "el espacio en blanco al final de la salida no está permitido". Esto parece tener espacios en blanco al final de cada línea corta en la salida, por lo que no estoy seguro de que cuente.
— papa
@potato Gracias, eso fue agregado desde que respondí.
— isaacg
31

vim, 43 36 35 bytes

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

Demasiado bueno para no publicarlo. Tenga en cuenta la nueva línea final; Es significativo.

¡Gracias a @Marth por salvar a un personaje!

formato compatible con vim:

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

Explicación:

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
— Pomo de la puerta
fuente
1
Seguramente todo esto debe hacerse en modo Insertar, ¿verdad?
— Alex A.
9
@AlexA. Nada de esto se hace en modo de inserción. ಠ_ಠ
— Pomo
Si usa sor!para invertir el orden de clasificación, puede usar col("$")para obtener la longitud de la primera línea (ahora la más larga desde que se invierte el orden) en lugar de usar G$, ¡ahorrando un gran total de 1 byte! editar : o podría mantener el orden de clasificación y usar G:let &tw=col("$")en su lugar.
— Marth
@Marth ¡Gracias! Elegí este último (sin ninguna razón en particular).
— Pomo de la puerta
Al revisar :h :sort, acabo de descubrir que puede pasar una expresión regular para omitir el texto correspondiente en el orden, por lo que puede usar :sor /./para ordenar por longitud (+4 bytes), lo que le permite eliminar el VGrx(-4 bytes) y el segundo deshacer ( -1 bytes). También puede usar |separadores en lugar de <cr>encadenar los comandos, lo que le permite omitir el :anterior let(-1 bytes) (tenga en cuenta que debe usar la sor!solución entonces, Gno es un comando ex). Entonces :sor! /./|let &tw=col("$")|u|%ce (con un final <CR>) debería ahorrar 2 bytes.
— Marth
23

Mathematica, 96 bytes

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

No me pregunten cómo funcionó, solo jugueteé con él hasta que produjo el resultado correcto.

— LegionMammal978
fuente
27
+1 para "No me pregunten cómo funcionó, simplemente jugueteé con él hasta que produjo la salida correcta"
— cat
44
@cat Así es como hago todo mi golf.
— lirtosiast
11

Funciton , no competitivo

Este desafío ha resaltado la falta de una función de "valor máximo" (y valor mínimo) para las secuencias diferidas, así que ... las agregué a la biblioteca central (se llaman ⊤ y ⊥, respectivamente). Por lo tanto, no me molesté en enviar esto como una respuesta de golf (tendría que incluir la declaración de función ⊤ para ser válida), así que aquí está solo el programa principal.

Ejecute (function(){$('pre,code').css({lineHeight:5/4,fontFamily:'DejaVu Sans Mono'});})()en la consola de su navegador para obtener una mejor representación.

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

Explicación

Creo que esta puede ser la primera respuesta de Funciton en este sitio que utiliza expresiones lambda.

  • Primero, usamos ǁpara dividir la cadena de entrada en las nuevas líneas (ASCII 10). Esto devuelve una secuencia perezosa.
  • Pasamos esa secuencia a través de ɱ(mapa), dándole una lambda que calcula la longitud de cada cadena, y luego pasamos la secuencia final ⊤para obtener la longitud de la línea más larga.
  • Nosotros también pasar esa secuencia a través de otro ɱ, dándole un lambda que calcula la longitud de cada cadena, lo resta de la longitud máxima de línea calculada anteriormente, divisiones que por 2 (en realidad SHIFT-derecho 1), genera que muchos espacios (ASCII 32) y luego concatena la cadena en esos espacios. (Por razones geométricas, declaró una ‡función que llama ‼(concatenación de cadenas) con los parámetros invertidos).
  • Finalmente, usamos ʝpara volver a unir todas las cadenas, usando nuevas líneas (ASCII 10) como separador.
— Timwi
fuente
+1 por lo increíble que es esto y "Son 716 caracteres, un total de 1,508 bytes"
— cat
9

Retina , 54 52 bytes

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

La \ts se puede reemplazar con pestañas reales, pero la he usado \taquí, porque de lo contrario SE convertirá las pestañas a espacios. Tenga en cuenta que hay un espacio inicial en la segunda línea.

Pruébalo en línea.

Explicación

La idea básica es hacer coincidir una línea que sea al menos dos caracteres más corta que la línea más larga (o técnicamente, dos caracteres más cortos que cualquier otra línea), y rodearla en dos espacios. Esto se repite hasta que ya no podamos encontrar una línea de este tipo, lo que significa que todas las líneas están dentro de un carácter de la longitud máxima (donde el único carácter debe tener en cuenta los desajustes de paridad, y garantiza que estas líneas se desplazan hacia la izquierda) centrar).

En cuanto a la expresión regular real:

^(.)+$

Simplemente coincide con cualquier línea mientras empuja una captura al grupo 1para cada personaje.

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

Es una mirada hacia atrás que se corresponde de derecha a izquierda y mueve el cursor al comienzo de la cadena, de modo que la búsqueda anticipada en el interior pueda verificar la cadena completa. Tenga en cuenta que debido a la falta de un ancla, la búsqueda anticipada podría aplicarse desde cualquier otro lugar, pero eso no crea coincidencias adicionales. Sabemos que [^\t]siempre coincidirá con cualquier carácter en la cadena, porque la entrada está garantizada para contener solo espacios y saltos de línea en lo que respecta al espacio en blanco.

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

Esta búsqueda anticipada intenta encontrar una línea que tenga al menos dos caracteres más que la que estamos haciendo coincidir actualmente. [^\t]*se mueve a través de la cadena para poder coincidir con cualquier línea. ^asegura que empecemos desde el principio de la línea. ..luego coincide con los dos caracteres adicionales que requerimos para la línea más larga. Ahora (?<-1>.)+coincide con los caracteres individuales en esa línea mientras emerge del grupo 1(tenga en cuenta que .no puede coincidir con un salto de línea, por lo que está limitado a una línea). Finalmente, (?(1)^)afirma que logramos vaciar todo el grupo 1. Si la línea es más corta de lo requerido, esto no es posible, porque no hay suficientes caracteres en la línea para saltar del grupo 1 con la frecuencia suficiente para vaciarla.

— Martin Ender
fuente
7

Jolf , 3 bytes

Sin competencia, pregunta de actualización de fechas posteriores.

Pruébalo aquí! .

pci
pc  center
  i  string input

¯ \ _ (ツ) _ / ¯ Pensé que sería una función útil.

— Conor O'Brien
fuente
1
Esta es una laguna estándar, y aunque no está explícitamente deshabilitada, es una forma incorrecta a menos que esté integrada en un lenguaje que encuentre, no en uno que cree.
— Elias Benevedes
3
@EliasBenevedes Agregué la función antes del concurso. No suelo actualizar mi código hasta que se vuelve relevante.
— Conor O'Brien
7

JavaScript (ES6), 93 91 bytes

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 bytes guardados gracias a @ edc65 !

Explicación

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

Prueba

Mostrar fragmento de código

— usuario81655
fuente
.repeatacepta y trunca valores no enteros, por lo que no es necesario|0
— edc65
7

CJam, 26 23 19 bytes

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

¡Mi primera vez usando CJam! Cuatro bytes guardados gracias a Martin Büttner. Pruébalo en línea.

Explicación

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
}
— NinjaOsoMono
fuente
1
Aquí hay algunas sugerencias :)qN/_z,f{1$,m2/S*\N}
— Martin Ender
6

LabVIEW, 3 o 35 primitivas de LabVIEW

Encuentra líneas hasta que no quede ninguna, luego calcula cuántos espacios agregar y pone todo junto.

Alternativamente, podría usar la alineación central incorporada en los indicadores de cadena, aunque se siente como hacer trampa.

— Eumel
fuente
6

Pitón 2, 83 81 bytes

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

Gracias a @xnor por guardar 2 caracteres

entrada de ejemplo:

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

salida de ejemplo:

Programming Puzzles
         &
     Code Golf

Y termina en segundo lugar con 84 bytes usando str.center () y str.rstrip (gracias @JF).

def f(s):
 t=s.split('\n')
 for y in t:print y.center(max(len(f)for f in t)).rstrip()
— Willem
fuente
No guarda caracteres para asignar lena una variable que usa dos veces, que se iguala en 5 caracteres (como range). Además, puede usar mappara la lista de comp.
— xnor
@Willem, puede usar str.rstrip()después de llamar centerpara deshacerse del espacio final.
— JF
Puede guardar 7 bytes con un programa completo y usando len(max(a,key=len)), vea esto .
— ბიმო
5

TeaScript , 24 bytes

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

Recorre las líneas, agrega floor((max line length - line length) / 2)espacios al principio.

Sin golf

£   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`)

Pruébalo en línea

— Downgoat
fuente
55
¿Por qué mis respuestas siguen siendo Downgoated? Creo que es hora de cambiar el nombre de usuario / avatar: p
— Downgoat
Fijo a partir del 27/07/2016. : P
— user48538
5

PowerShell, 58 67 bytes

hasta 58 bytes gracias a los comentarios de @ 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
  • Toma una serie de cadenas mientras $a, recorre cada cadena con |%{...}.
  • llama al string.padleft()método en cada cadena, a través de un % -memberacceso directo, que toma la longitud de línea final deseada como parámetro.
    • necesitamos array_longest_line_length/2 + current_line_length/2
    • la parte final es current_line_length/2->$_.length/2
    • la otra parte está recalculando la longitud máxima de la línea de la matriz cada vez a través del bucle, y lo hace con un bucle anidado que forma una matriz de longitudes de línea, ordena eso y luego toma la última.
— TessellatingHeckler
fuente
— mazzy
1
@mazzy eso es mejor! Como no publicaste como respuesta, lo he editado en mi respuesta con crédito.
— TessellatingHeckler
3

Emacs Lisp, 203 bytes

(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)))))

Sin golf:

(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)))))

Centrado:

               (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
fuente
3

HTML, 40 bytes

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

Mostrar fragmento de código

El </xmp>fragmento incluye una etiqueta porque el visor de fragmentos de código desea que mis etiquetas estén equilibradas.

— Neil
fuente
2

MATL , 22 31 bytes

`jtYz~]xXhc4X4H$ZuZ{Zv

Cada línea se ingresa con una línea final (es decir, una enterpulsación de tecla). Una línea vacía (dosenter pulsaciones de teclas) marca el final de la entrada.

Ejemplo

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

Explicación

`          % 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
fuente
2

Ruby, 76 68 61 bytes

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

Ejecución de muestra:

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
— hombre trabajando
fuente
53 bytes:->t{(s=t.split$/).map{|l|l.center s.map(&:size).max}}
— daniero
También probé el centercamino primero, pero según tengo entendido, eso solo rompería la regla "No se permite el espacio en blanco al final de la salida". Gracias por la &:sizeparte. También probé eso también, pero ciertamente golpeé algo alrededor de la sintaxis.
— manatwork
2

Haskell, 111 81 77 bytes

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

Entrada a la función f, la salida no se imprime.

Uso: cargar en el intérprete ghci center.hsy luego si desea imprimir la salida de f en una cadena dadaputStr$f"Programming Puzzles\n&\nCode Golf"

Editar: Gracias a nimi por 34 bytes, ¡buen trabajo! :RE

— basile-henry
fuente
Dos cosas más: La última versión del preludio incluye una versión infija de map: <$>. replicate(...)' 'puede ser sustituido por [1.. ...]>>" ". En resumen: unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q].
— nimi
Ah sí, recuerdo que mencionaste el nuevo infijo del mapa en una presentación anterior que hice. ¿Cómo funciona el truco replicado?
— basile-henry
l1 >> l2realiza (longitud l1) copias de l2 y las concatena. Por ejemplo, "abcd" >> [1,2]-> [1,2,1,2,1,2,1,2](<- 4 copias de 1,2 en una sola lista). En nuestro caso, lo [1..n]>>" "que es n copias de un espacio es lo mismo que lo que replicatehace.
— nimi
Bien, gracias por la explicación! :)
— basile-henry
2

R, 126 bytes

código

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="")}

sin golf

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="")
  }
}

Probablemente hay formas mucho mejores de hacerlo, aún trabajando en ello.

— Mutador
fuente
1

Gema, 160 bytes

\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

Escrito principalmente para mi curiosidad por ver qué se puede hacer en un lenguaje sin la estructura de matriz adecuada y la instrucción de bucle adecuada.

Ejecución de muestra:

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
— hombre trabajando
fuente
1

Perl 6 , 61 bytes

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

uso: 

$ perl6 -e '$/=(my@l=lines)».chars.max;for @l {put " "x($/-.chars)/2~$_}' <<< \
'Programming Puzzles
&
Code Golf'
Programming Puzzles
         &
     Code Golf
— Brad Gilbert b2gills
fuente
Perl 5 le permitiría colocar los espacios en cosas como for @l {, afeitar 2 bytes, y cambiar put " "a put" ", afeitar otro byte. ¿Es eso cierto para Perl 6? (No sé Perl 6.) Además, su salida como se muestra aquí no coincide con la salida requerida; ¿Es eso un error tipográfico?
— msh210
@ msh210 Perl 6 es un poco más restrictivo con su sintaxis. Sin embargo, lo compensa con creces en otras áreas.
— Brad Gilbert b2gills
1

Japt, 28 25

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

Pruébalo en línea!

Cómo funciona

¡     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.
— ETHproducciones
fuente
0

PHP , 98 bytes

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

Pruébalo en línea!

Sin golf:

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;
    }
}

Salida:

Programming Puzzles
         &         
     Code Golf
— 640 KB
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.