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

var QUESTION_ID=66731,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

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

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.

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

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.

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.

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.

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.

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

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

<textarea id="input" rows="4" cols="20">Programming Puzzles
&
Code Golf</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

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
}

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.

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

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

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.

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

HTML, 40 bytes

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

<xmp style=float:left;text-align:center>
Programming Puzzles
&
Code Golf
</xmp>

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

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

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

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

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.

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

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

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.

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   

05AB1E , 2 bytes

.c

Construido ftw ¯ \ _ (ツ) _ / ¯

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

.c   # Centralize the (implicit) multi-line input-string with preference to the left
     # (output the result implicitly)

(La preferencia a la derecha sería con una mayúscula en su .Clugar: vea las diferencias ).

Japt , 1 byte

û

Pruébalo o ejecuta todos los casos de prueba