Zentrieren Sie den Text!

In dieser Herausforderung werden Sie verschiedene Linien zentrieren.

Beispiele

Foo
barbaz

 Foo
barbaz

Hello
World

Hello
World

Programming Puzzles
&
Code Golf

Programming Puzzles
         &
     Code Golf

Spezifikationen

Jede Eingabezeile enthält immer mindestens ein Nicht-Leerzeichen. Sie können davon ausgehen, dass Leerzeichen ( ) und Zeilenumbrüche das einzige Leerzeichen sind . Jede Eingabezeile enthält kein nachgestelltes und / oder führendes Leerzeichen (mit Ausnahme der neuen Zeile). Ein nachgestelltes Leerzeichen in der Ausgabe ist nicht zulässig.

Sie sollten sich auf der längsten Zeile in der Eingabe befinden. Wenn diese Linie gerade ist, sollte Ihr Programm / Ihre Funktion es vorziehen, nach links zu zentrieren. Die maximale Zeilenlänge hängt davon ab, mit welcher Sprache Sie umgehen können, Ihr Programm sollte jedoch für Zeilen mit einer Länge von mindestens 500 funktionieren.

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

# [><>](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>

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes!

Pyth, 19 17 Bytes

2 Bytes dank Jakube

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

Demonstration

Ich denke, dies ist das erste Mal, dass die Center-Pad-Funktion von .[nützlich ist. Die Länge der längsten Zeile wird mit transponiert ( .T) ohne Kürzung ermittelt .

Nachgestellte Leerzeichen werden entfernt, indem ein Nicht-Leerzeichen an der Vorderseite eingefügt, Leerzeichen entfernt und das hinzugefügte Zeichen entfernt wird.

vim, 43 36 35 Bytes

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

Zu gut um nicht zu posten. Beachten Sie den nachgestellten Zeilenumbruch. es ist bedeutend.

Vielen Dank an @Marth für das Speichern eines Charakters!

vim-freundliches Format:

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

Erläuterung:

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~"
"),"
"]&

Fragen Sie mich nicht, wie es funktioniert, ich habe nur herumgespielt, bis es die richtige Ausgabe lieferte.

Funktion , nicht wettbewerbsfähig

Diese Herausforderung hat das schmerzhafte Fehlen einer "Maximalwert" - (und Minimalwert-) Funktion für Lazy Sequences hervorgehoben, also ... habe ich sie der Kernbibliothek hinzugefügt (sie heißen ⊤ bzw. ⊥). Daher habe ich mir nicht die Mühe gemacht, diese Antwort als Golf- Antwort einzureichen (sie müsste die ⊤-Funktionserklärung enthalten, um gültig zu sein). Hier ist also nur das Hauptprogramm.

Führen Sie dies (function(){$('pre,code').css({lineHeight:5/4,fontFamily:'DejaVu Sans Mono'});})()in Ihrer Browser-Konsole aus, um ein besseres Rendering zu erhalten.

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

Erläuterung

Ich glaube, dies ist möglicherweise die erste Antwort von Funciton auf dieser Website, die Lambda-Ausdrücke verwendet.

• Zunächst ǁteilen wir die Eingabezeichenfolge an den Zeilenumbrüchen auf (ASCII 10). Dies gibt eine verzögerte Sequenz zurück.
• Wir durchlaufen diese Sequenz ɱ(map), geben ihr ein Lambda, das die Länge jeder Zeichenkette berechnet, und übergeben dann die endgültige Sequenz ⊤, um die Länge der längsten Linie zu ermitteln.
• Wir auch passieren , dass die Sequenz durch eine andere ɱ, eine Lambda - geben, die die Länge jeder Zeichenfolge berechnet, subtrahiert von der maximalen Zeilenlänge früher berechnet, dividieren , dass um 2 (tatsächlich shift-rechts 1) erzeugt , die viele Zwischenräume (ASCII 32) und verkettet dann die Zeichenfolge auf diese Leerzeichen. (Aus geometrischen Gründen habe ich eine ‡Funktion deklariert , die ‼(String-Verkettung) mit umgekehrten Parametern aufruft .)
• Zum Schluss setzen wir ʝalle Zeichenfolgen wieder zusammen und verwenden als Trennzeichen Zeilenumbrüche (ASCII 10).

Netzhaut , 54 52 Bytes

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

Das \ts kann durch aktuelle Tabs ersetzt werden, habe ich aber \thier verwendet, da sonst SE die Tabs in Leerzeichen konvertiert. Beachten Sie, dass in der zweiten Zeile ein vorangestelltes Leerzeichen steht.

Probieren Sie es online aus.

Erläuterung

Die Grundidee besteht darin, eine Zeile abzugleichen, die mindestens zwei Zeichen kürzer als die längste Zeile ist (oder technisch gesehen zwei Zeichen kürzer als jede andere Zeile), und sie in zwei Leerzeichen zu umgeben. Dies wird so oft wiederholt, bis wir eine solche Zeile nicht mehr finden. Dies bedeutet, dass sich alle Zeilen innerhalb eines Zeichens der maximalen Länge befinden (wobei das eine Zeichen für Paritätsinkongruenzen verantwortlich ist und gewährleistet, dass diese Zeilen nach links verschoben werden). Center).

Wie für die eigentliche Regex:

^(.)+$

Stimmt nur mit einer Zeile überein, während 1für jeden Charakter eine Aufnahme in die Gruppe verschoben wird.

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

Ist ein Lookbehind, der von rechts nach links abgeglichen wird und den Cursor an den Anfang der Zeichenfolge bewegt, sodass der Lookahead innerhalb der Zeichenfolge die gesamte Zeichenfolge überprüfen kann. Beachten Sie, dass der Lookahead aufgrund des Fehlens eines Ankers von einer anderen Stelle aus angewendet werden kann, jedoch keine zusätzlichen Übereinstimmungen erstellt werden. Wir wissen, dass [^\t]immer jedes Zeichen in der Zeichenfolge übereinstimmt , da die Eingabe in Bezug auf Leerzeichen und Zeilenvorschübe garantiert nur Leerzeichen und Zeilenvorschübe enthält.

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

Dieser Lookahead versucht, eine Zeile zu finden, die mindestens zwei Zeichen länger ist als die, zu der wir gerade eine Übereinstimmung finden. [^\t]*Bewegt sich durch die Zeichenfolge, um mit einer beliebigen Zeile übereinstimmen zu können. ^stellt sicher, dass wir am Anfang der Zeile beginnen. ..Dann stimmen die beiden zusätzlichen Zeichen überein, die wir für die längere Zeile benötigen. Stimmt jetzt (?<-1>.)+mit einzelnen Zeichen in dieser Zeile überein, während Sie aus der Gruppe springen 1(Anmerkung, .die keinem Zeilenvorschub entsprechen, daher ist dies auf eine Zeile beschränkt). Schließlich wird (?(1)^)behauptet, dass es uns gelungen ist, die gesamte Gruppe zu leeren 1. Wenn die Zeile kürzer als erforderlich ist, ist dies nicht möglich, da nicht genügend Zeichen in der Zeile vorhanden sind, um aus Gruppe 1 häufig genug einzufügen, um sie zu leeren.

Jolf , 3 Bytes

Nicht konkurrierende Frage nach Datum aktualisieren.

Probieren Sie es hier aus! .

pci
pc  center
  i  string input

¯ \ _ (ツ) _ / ¯ Ich dachte, es wäre eine nützliche Funktion.

JavaScript (ES6), 93 bis 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 Bytes gespart dank @ edc65 !

Erläuterung

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

Prüfung

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}

Mein erstes Mal mit CJam! Vier Bytes gespart dank Martin Büttner. Probieren Sie es online aus.

Erläuterung

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 oder 35 LabVIEW-Grundelemente

Findet Linien, bis keine mehr übrig sind, berechnet dann die Anzahl der hinzuzufügenden Leerzeichen und fügt alles zusammen.

Alternativ können Sie die eingebaute Mittenausrichtung für die Saitenanzeigen verwenden, es fühlt sich jedoch irgendwie nach Schummeln an.

Python 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  

Vielen Dank an @xnor für das Speichern von 2 Zeichen

Beispiel Eingabe:

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

Beispielausgabe:

Programming Puzzles
         &
     Code Golf

Und auf dem zweiten Platz mit 84 Bytes mit str.center () und str.rstrip (danke @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,§)

Durchläuft Linien und fügt floor((max line length - line length) / 2)Leerzeichen am Anfang ein.

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

Probieren Sie es online aus

PowerShell, 58 67 Byte

durch @ mazzy Kommentare auf 58 Bytes reduziert:

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

• Es nimmt ein Array von Strings als $a, die mit jedem String durchlaufen werden |%{...}.
• Ruft die string.padleft()Methode für jede Zeichenfolge über eine % -memberVerknüpfung auf, die die gewünschte endgültige Zeilenlänge als Parameter verwendet.
  • wir brauchen array_longest_line_length/2 + current_line_length/2
  • Der Endteil ist current_line_length/2->$_.length/2
  • Der andere Teil berechnet die maximale Zeilenlänge des Arrays jedes Mal neu, und zwar mit einer verschachtelten Schleife, die ein Array von Zeilenlängen erstellt, diese sortiert und dann die letzte übernimmt.

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

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

Zentriert:

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

Snippet enthält </xmp>Tag, da der Code-Snippet-Viewer möchte, dass meine Tags ausgeglichen sind.

MATL , 22 31 Bytes

`jtYz~]xXhc4X4H$ZuZ{Zv

Jede Zeile wird mit einer abschließenden Zeile ( enterdh einem Tastendruck) eingegeben . Eine leere Zeile (zwei enterTastenanschläge) markiert das Ende der Eingabe.

Beispiel

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

Erläuterung

`          % 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}}

Probelauf:

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]

Eingabe in die f-Funktion, die Ausgabe wird nicht gedruckt.

Verwendung: Lade in den Interpreter ghci center.hsund dann, wenn du die Ausgabe von f auf einen gegebenen String drucken willstputStr$f"Programming Puzzles\n&\nCode Golf"

Edit: Danke an nimi für 34 Bytes, tolle Arbeit! : D

R, 126 Bytes

Code

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

Wahrscheinlich gibt es bessere Möglichkeiten, dies zu tun, und wir arbeiten noch daran.

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

Geschrieben hauptsächlich aus Neugier, um zu sehen, was in einer Sprache ohne die richtige Array-Struktur und die richtige Schleifenanweisung möglich ist.

Probelauf:

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

Verwendungszweck:

$ 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

Probieren Sie es online!

Wie es funktioniert

¡     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),"
";}

Probieren Sie es 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;
    }
}

Ausgabe:

Programming Puzzles
         &         
     Code Golf   

05AB1E , 2 Bytes

.c

Builtins ftw \ _ (ツ) _ /

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

(Bevorzugung rechts wäre stattdessen mit einem Großbuchstaben .C: siehe die Unterschiede .)

Japt , 1 Byte

û

Probieren Sie es aus oder führen Sie alle Testfälle aus