Zentrieren Sie den Text!

40

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

Code-Snippet anzeigen

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

code-golf  string  typography 
— Downgoat
quelle
Es wird nie mehr als einen Innenraum geben?
— Katze
@cat wird es nie sein jede auf einer Linie führende Leerzeichen oder nachfolgende Leerzeichen (für die Newline erwarten , wenn es eine gibt)
— Downgoat
Ja, aber ich meine innere -Räume, wie, zwischen den Wörtern
— Katze
1
@cat oh, zwischen Wörtern kann es mehr als ein Leerzeichen geben. Zum Beispiel foo(space)(space)(space)barist eine völlig akzeptable Eingabe
— Downgoat
können wir davon ausgehen, dass es immer mehr als eine Zeile geben wird?
— GamrCorps

Antworten:

15

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.

— isaacg
quelle
1
Wir brauchen wahrscheinlich eine maximale Länge im Array. Es kommt viel zu oft auf. +1
— Maltysen
In den Spezifikationen heißt es, dass "Nachgestellte Leerzeichen in der Ausgabe nicht zulässig sind." Dies scheint nachgestellte Leerzeichen in jeder kurzen Zeile in der Ausgabe zu haben, daher bin ich mir nicht sicher, ob es zählt.
— Kartoffel
@potato Danke - das wurde hinzugefügt, seit ich geantwortet habe.
— isaacg
31

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
— Türknauf
quelle
1
Sicherlich sollte dies alles im Einfügemodus erfolgen, oder?
— Alex A.
9
@AlexA. Nichts davon wird im Einfügemodus ausgeführt. ಠ_ಠ
— Türklinke
Wenn Sie sor!zum Umkehren der Sortierreihenfolge verwenden, können Sie col("$")die Länge der ersten Zeile (jetzt die längste seit der Umkehrung der Reihenfolge) ermitteln, anstatt zu verwenden G$, wodurch insgesamt 1 Byte gespart wird! edit : oder Sie können die Sortierreihenfolge beibehalten und G:let &tw=col("$")stattdessen verwenden.
— Marth
@Marth Danke! Ich habe mich für Letzteres entschieden (ohne besonderen Grund).
— Türklinke
Beim Durchsuchen habe :h :sortich gerade herausgefunden, dass Sie einen regulären Ausdruck verwenden können, um den übereinstimmenden Text in der Sortierung zu überspringen, sodass Sie :sor /./nach Länge (+4 Byte) sortieren können , wodurch Sie die VGrx(-4 Byte) und die zweite Rückgängigmachung entfernen können ( -1 Bytes). Sie können auch |Trennzeichen verwenden, anstatt <cr>die Befehle zu verketten, wodurch Sie das :Vorher let(-1 Byte) überspringen können (beachten Sie, dass Sie die sor!Lösung dann verwenden müssen, Gkein Ex-Befehl ist). Also :sor! /./|let &tw=col("$")|u|%ce (mit einem Trailing <CR>) sollten 2 Bytes gespart werden.
— Marth
23

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.

— LegionMammal978
quelle
27
+1 für "Frag mich nicht, wie es funktioniert hat, ich habe nur herumgespielt, bis es die richtige Ausgabe erzeugt hat"
— cat
4
@cat So mache ich all mein Golfen.
— Lirtosiast
11

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).
— Timwi
quelle
+1 für wie genial das ist und "Das sind 716 Zeichen, insgesamt 1.508 Bytes"
— cat
9

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.

— Martin Ender
quelle
7

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.

— Conor O'Brien
quelle
1
Dies ist eine Standardlücke, die zwar nicht ausdrücklich untersagt ist, aber ihre schlechte Form, es sei denn, sie ist in eine Sprache eingebaut, die Sie finden, und nicht in eine, die Sie erstellen.
— Elias Benevedes
3
@EliasBenevedes Ich habe die Funktion vor dem Wettbewerb hinzugefügt. Ich aktualisiere meinen Code nicht oft, bis er relavent wird.
— Conor O'Brien
7

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

Code-Snippet anzeigen

— user81655
quelle
.repeatAkzeptiert und schneidet nicht ganzzahlige Werte ab, sodass Sie sie nicht benötigen|0
— edc65
7

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
}
— NinjaBearMonkey
quelle
1
Hier sind einige Vorschläge :)qN/_z,f{1$,m2/S*\N}
— Martin Ender
6

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.

— Eumel
quelle
6

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()
— Willem
quelle
Es werden keine Zeichen gespeichert, um lensie einer Variablen zuzuweisen , die Sie zweimal verwenden - das entspricht einer Gewinnschwelle von 5 Zeichen (wie range). Sie können auch mapfür die Liste comp verwenden.
— Xnor
@ Willem, könnten Sie str.rstrip()nach dem Aufruf verwenden center, um den abschließenden Raum loszuwerden.
— JF
Sie können 7 Bytes mit einem vollständigen Programm speichern und verwenden len(max(a,key=len)), siehe dies .
— 23.
5

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

— Downgoat
quelle
5
Warum werden meine Antworten immer schlechter? Ich denke, es ist Zeit, den Benutzernamen / Avatar zu ändern: p
— Downgoat
Behoben ab 27.07.2016. : P
— user48538
5

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.
— TessellatingHeckler
quelle
— mazzy
1
@mazzy das ist besser! da du nicht als antwort gepostet hast, habe ich das mit gutschrift in meine antwort eingearbeitet.
— 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)))))

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)))))
— Lord Yuuma
quelle
3

HTML, 40 Bytes

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

Code-Snippet anzeigen

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

— Neil
quelle
2

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
— Luis Mendo
quelle
2

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
— Mann bei der Arbeit
quelle
53 Bytes:->t{(s=t.split$/).map{|l|l.center s.map(&:size).max}}
— Daniero
Ich habe auch den centerWeg zuerst ausprobiert , aber wie ich verstehe, würde das allein die Regel "Hinteres Leerzeichen in der Ausgabe ist nicht zulässig" brechen. Vielen Dank für den &:sizeTeil - das habe ich auch versucht, aber ich habe auf jeden Fall etwas an der Syntax herumgeschubst.
— 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]

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

— Basilikum-Henry
quelle
Zwei weitere Dinge: Die neueste Version des Vorspiels enthält eine Infix - Version map: <$>. replicate(...)' 'kann durch ersetzt werden [1.. ...]>>" ". Alles in allem: unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q].
— nimi
Ah ja, ich erinnere mich, dass Sie das neue Karten-Infix in einem früheren Beitrag erwähnt haben. Wie funktioniert der Replikatstrick?
— basile-henry
l1 >> l2erstellt (Länge l1) Kopien von l2 und verkettet sie. ZB "abcd" >> [1,2]-> [1,2,1,2,1,2,1,2](<- 4 Kopien von 1,2 in einer einzigen Liste). In unserem Fall sind es [1..n]>>" "n Kopien eines Raums, die mit dem identisch sind, was er replicatetut.
— nimi
Schön, danke für die Erklärung! :)
— basile-henry
2

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.

— Mutador
quelle
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

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
— Mann bei der Arbeit
quelle
1

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
— Brad Gilbert b2gills
quelle
Perl 5 erlaubt es dir , die Räume in Dinge wie zu fallen for @l {, Rasieren 2 Bytes, und Änderungen put " "zu put" ", ein weiteres Byte rasieren. Gilt das für Perl 6? (Ich kenne Perl 6 nicht.) Außerdem stimmt Ihre Ausgabe, wie sie hier angezeigt wird, nicht mit der erforderlichen Ausgabe überein. ist das ein Tippfehler?
— msh210
@ msh210 Perl 6 ist in seiner Syntax etwas restriktiver. In anderen Bereichen macht es das mehr als wett.
— Brad Gilbert b2gills
1

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.
— ETHproductions
quelle
0

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
— 640 KB
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.