Centrer le texte!

40

Centrer le texte!

Dans ce défi, vous allez centrer différentes lignes.

Exemples

Foo
barbaz

 Foo
barbaz

Hello
World

Hello
World

Programming Puzzles
&
Code Golf

Programming Puzzles
         &
     Code Golf

Caractéristiques

Chaque ligne d’entrée aura toujours au moins un caractère non blanc, vous pouvez donc supposer que le seul caractère blanc est un espace ( ) et une nouvelle ligne. Chaque ligne d'entrée n'aura pas d'espaces de fin et / ou de début (à l'exception de la nouvelle ligne). Les espaces de fin dans la sortie ne sont pas autorisés.

Vous devriez vous centrer sur la plus longue ligne de l'entrée. Si la longueur de cette ligne est uniforme, votre programme / fonction devrait préférer se centrer vers la gauche. La longueur de ligne maximale est celle que votre langue peut gérer, mais votre programme doit fonctionner sur des lignes d'au moins 500 caractères.

Classement

Voici un extrait de pile permettant de générer un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

C'est du code-golf, donc le code le plus court en octets gagne!

code-golf  string  typography 
— Downgoat
source
Il n'y aura jamais plus d'un espace intérieur?
— Chat
@cat, il n'y aura jamais d' espaces de début ou de fin de ligne sur une ligne (attendez-vous à la nouvelle ligne s'il en existe une)
— Downgoat
oui, mais je veux dire des espaces intérieurs , comme, entre les mots
— Cat
1
@cat oh, entre les mots, il peut y avoir plus d'un espace. Par exemple foo(space)(space)(space)barest une entrée parfaitement acceptable
— Downgoat
pouvons-nous supposer qu'il y aura toujours plus d'une ligne?
— GamrCorps

Réponses:

15

Pyth, 19 17 octets

2 octets grâce à Jakube

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

Manifestation

Je pense que c'est la première fois que la fonction de pad central .[est utile. La longueur de la plus longue ligne est trouvée en utilisant une transposition non tronquée (.T ) .

Les espaces de fin sont supprimés en ajoutant un caractère non-espace au premier plan, en supprimant les espaces, puis en supprimant le caractère ajouté.

— isaacg
source
1
Nous avons probablement besoin d'une longueur maximale dans array. Cela revient trop souvent. +1
— Maltysen
Les spécifications indiquent que "les espaces de fin dans la sortie ne sont pas autorisés". Il semble y avoir des espaces à la fin de chaque ligne courte de la sortie. Je ne suis donc pas sûr que cela compte.
— pomme de terre
@potato Merci - cela a été ajouté depuis que j'ai répondu.
— isaacg
31

vim, 43 36 35 octets

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

Trop bien pour ne pas publier. Notez le retour à la ligne suivant; c'est important.

Merci à @Marth d' avoir sauvé un personnage!

format convivial:

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

Explication:

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
— Poignée de porte
source
1
Tout cela devrait sûrement être fait en mode Insertion, non?
— Alex A.
9
@Alexa. Rien de tout cela est fait en mode insertion. _ಠ
— Poignée de porte
Si vous utilisez sor!pour inverser l'ordre de tri, vous pouvez utiliser col("$")pour obtenir la longueur de la première ligne (maintenant la plus longue depuis l'ordre inversé) au lieu de l'utiliser G$, en enregistrant un total général de 1 octet! edit : ou vous pouvez conserver l'ordre de tri et utiliser à la G:let &tw=col("$")place.
— Marth
@Marth Merci! J'ai choisi ce dernier (sans raison particulière).
— Poignée de porte
En regardant à travers, :h :sortje viens de découvrir que vous pouvez passer une expression rationnelle pour ignorer le texte correspondant dans le tri, afin que vous puissiez utiliser :sor /./pour trier sur la longueur (+4 octets), ce qui vous permet de supprimer le VGrx(-4 octets) et le deuxième annulation ( -1 octets). Vous pouvez également utiliser des |séparateurs au lieu de <cr>chaîner les commandes, ce qui vous permet de passer à l’ :avant.let (-1 octets) (notez que vous devez utiliser la sor!solution alors, ce Gn’est pas une commande ex). Donc :sor! /./|let &tw=col("$")|u|%ce (avec une fin <CR>) devrait économiser 2 octets.
— Mars
23

Mathematica, 96 octets

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

Ne me demandez pas comment cela a fonctionné, je me suis contenté de le manipuler jusqu'à ce que le résultat soit correct.

— LegionMammal978
source
27
+1 pour "Ne me demandez pas comment cela a fonctionné, je l'ai juste tripoté jusqu'à ce que le résultat soit correct"
— cat
4
@cat C'est comme ça que je fais tout mon golf.
— lirtosiast
11

Funciton , non compétitif

Ce défi a mis en lumière le manque flagrant de fonction de «valeur maximale» (et de valeur minimale) pour les séquences paresseuses, alors ... je les ai ajoutées à la bibliothèque principale (elles s'appellent respectivement et ⊥). Par conséquent, je n'ai pas pris la peine de soumettre cela comme réponse au golf (il faudrait inclure la déclaration de fonction pour être valide), alors voici simplement le programme principal.

Exécuter (function(){$('pre,code').css({lineHeight:5/4,fontFamily:'DejaVu Sans Mono'});})() dans la console de votre navigateur pour obtenir un rendu plus agréable.

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

Explication

Je pense que c'est peut-être la première réponse Funciton sur ce site qui utilise des expressions lambda.

  • Tout d'abord, nous utilisons ǁ divisons la chaîne d’entrée au niveau des nouvelles lignes (ASCII 10). Cela retourne une séquence paresseuse.
  • Nous passons cette séquence à travers ɱ (map), en lui donnant un lambda qui calcule la longueur de chaque chaîne, puis nous passons la dernière séquence ⊤pour obtenir la longueur de la plus longue ligne.
  • Nous transmettons également cette séquence à une autre ɱ, en lui donnant un lambda qui calcule la longueur de chaque chaîne, la soustrait de la longueur de ligne maximale calculée précédemment, divise par 2 (en fait, shift-right 1) et génère autant d'espaces (ASCII 32). puis concatène la chaîne sur ces espaces. (Pour des raisons géométriques, j'ai déclaré une ‡fonction qui appelle‼ (concaténation de chaînes) les paramètres inversés.)
  • Enfin, nous avons l'habitude ʝde rassembler toutes les chaînes, en utilisant des nouvelles lignes (ASCII 10) comme séparateur.
— Timwi
source
— cat
9

Retina , 54 52 octets

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

Les \ts peuvent être remplacés par des onglets réels, mais je les ai utilisés \tici, sinon SE convertira les onglets en espaces. Notez qu'il y a un espace de début sur la deuxième ligne.

Essayez-le en ligne.

Explication

L’idée de base est de faire correspondre une ligne qui a au moins deux caractères plus courts que la plus longue ligne (ou, techniquement, deux caractères plus courts que n’importe quel caractère). autre ligne) et de l'entourer de deux espaces. Ceci est répété jusqu'à ce que nous ne puissions plus trouver une telle ligne, ce qui signifie que toutes les lignes sont comprises dans un caractère de la longueur maximale (le caractère devant rendre compte des asymétries de parité, et garantit que ces lignes sont décalées vers la gauche). centre).

En ce qui concerne la regex actuelle:

^(.)+$

Correspond juste à une ligne tout en poussant une capture sur le groupe 1pour chaque personnage.

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

Est un regard derrière qui correspond de droite à gauche et déplace le curseur au début de la chaîne, de sorte que le lookahead à l'intérieur puisse vérifier la chaîne entière. Notez qu'en raison d'un manque d'ancre, le lookahead peut être appliqué de n'importe où, mais cela ne crée pas de correspondances supplémentaires. Nous savons que tout caractère de la chaîne [^\t]correspondra toujours , car il est garanti que l'entrée ne contient que des espaces et des sauts de ligne en ce qui concerne les espaces.

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

Ce lookahead essaie de trouver une ligne qui a au moins deux caractères de plus que celle que nous comparons actuellement. [^\t]*se déplace dans la chaîne afin de pouvoir faire correspondre n'importe quelle ligne. ^assure que nous partons du début de la ligne. ..correspond ensuite aux deux caractères supplémentaires requis pour la ligne la plus longue. Correspond maintenant à (?<-1>.)+des caractères individuels de cette ligne lors de la sortie d'un groupe 1(remarque: il .est impossible de faire correspondre un saut de ligne, il est donc limité à une ligne). Enfin, (?(1)^)affirme que nous avons réussi à vider tout le groupe 1. Si la ligne est plus courte que nécessaire, cela n’est pas possible car il n’ya pas assez de caractères dans la ligne pour sortir du groupe 1 assez souvent pour la vider.

— Martin Ender
source
7

Jolf , 3 octets

Question non concurrente, mise à jour postdates.

Essayez-le ici! .

pci
pc  center
  i  string input

¯ \ _ (ツ) _ / ¯ Je pensais que ce serait une fonction utile.

— Conor O'Brien
source
1
Il s'agit d'une échappatoire standard et, sans être explicitement interdite, sa mauvaise forme, sauf si elle est intégrée à un langage que vous trouvez, pas à un que vous créez.
— Elias Benevedes
3
@EliasBenevedes J'ai ajouté la fonctionnalité avant le concours. Je ne mets pas souvent à jour mon code jusqu'à ce qu'il devienne relavent.
— Conor O'Brien
7

JavaScript (ES6), 93 91 octets

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 octets sauvés grâce à @ edc65 !

Explication

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

Tester

Afficher l'extrait de code

— utilisateur81655
source
.repeat accepte et tronque les valeurs non entières, vous n'avez donc pas besoin |0
— edc65
7

CJam, 26 23 19 octets

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

Ma première fois en utilisant CJam! Quatre octets économisés grâce à Martin Büttner. Essayez-le en ligne.

Explication

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
source
1
Voici quelques suggestions :)qN/_z,f{1$,m2/S*\N}
— Martin Ender
6

LabVIEW, 3 ou 35 primitives LabVIEW

Trouve les lignes jusqu'à ce qu'il n'en reste plus aucune, puis calcule le nombre d'espaces à ajouter et met tout ensemble.

Sinon, vous pouvez utiliser l'alignement central intégré sur les indicateurs de chaîne, mais vous avez l'impression de tricher.

— Eumel
source
6

Python 2, 83 81 octets

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

Merci à @xnor pour la sauvegarde de 2 caractères

exemple d'entrée:

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

exemple de sortie:

Programming Puzzles
         &
     Code Golf

Et se terminant à la deuxième place avec 84 octets en utilisant str.center () et str.rstrip (merci @JF).

def f(s):
 t=s.split('\n')
 for y in t:print y.center(max(len(f)for f in t)).rstrip()
— Willem
source
Cela ne sauvegarde pas les caractères à affecter lenà une variable que vous utilisez deux fois - cela casse même à 5 caractères (comme range). En outre, vous pouvez utiliser mappour la liste comp.
— xnor
@ Willem, vous pouvez utiliser str.rstrip()après avoir appelé centerpour vous débarrasser de l'espace de fuite.
— JF
Vous pouvez économiser 7 octets avec un programme complet et en utilisant len(max(a,key=len)) , voir ceci .
— ბიმო
5

TeaScript , 24 octets

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

Boucle à travers les lignes, ajoute floor((max line length - line length) / 2) espaces au début.

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

Essayez-le en ligne

— Downgoat
source
5
Pourquoi mes réponses ne cessent-elles de perdre leur sens? Je pense qu'il est temps de changer le nom d'utilisateur / avatar: p
— Downgoat
Fixé à partir du 2016-07-27. : P
— user48538
5

PowerShell, 58 67 octets

jusqu'à 58 octets grâce aux commentaires 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
  • Il faut un tableau de chaînes comme $a, boucle sur chaque chaîne avec|%{...} .
  • appelle la string.padleft()méthode sur chaque chaîne, via% -member raccourci, qui prend en paramètre la longueur de ligne finale souhaitée.
    • nous avons besoin array_longest_line_length/2 + current_line_length/2
    • la fin est current_line_length/2->$_.length/2
    • l'autre partie recalcule la longueur de ligne maximale du tableau à chaque passage dans la boucle, avec une boucle imbriquée qui crée un tableau de longueurs de ligne, le trie, puis prend le dernier.
— TessellatingHeckler
source
vous pouvez utiliser les noms de propriété de raccourcissement et la longueur des éléments pour obtenir 58 octets
— mazzy
1
@ Mazzy c'est mieux! comme vous n’avez pas posté de réponse, j’ai intégré cela dans ma réponse avec crédit.
— TessellatingHeckler
3

Emacs Lisp, 203 octets

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

Centré:

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

HTML, 40 octets

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

Afficher l'extrait de code

Snippet inclut </xmp>tag, car le visualiseur d'extraits de code souhaite que mes tags soient équilibrés.

— Neil
source
2

MATL , 22 à 31 octets

`jtYz~]xXhc4X4H$ZuZ{Zv

Chaque ligne est entrée avec une ligne de fin (c’est-à-dire un enter frappe). Une ligne vide (deuxenter frappes de touche) marque la fin de la saisie.

Exemple

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

Explication

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

Ruby, 76 68 61 octets

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

Échantillon échantillon:

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
— homme au travail
source
53 octets:->t{(s=t.split$/).map{|l|l.center s.map(&:size).max}}
— daniero
J'ai aussi essayé d' centerabord, mais si j'ai bien compris, cela enfreindrait la règle «Le suivi du blanc dans la sortie n'est pas autorisé». Merci pour la &:sizepartie - j'ai aussi essayé cela aussi, mais j'ai certainement frappé quelque chose autour de la syntaxe.
— manatwork
2

Haskell, 111 81 77 octets

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

Si vous entrez dans la fonction f, la sortie n’est pas imprimée.

Utilisation: chargez dans l'interpréteur ghci center.hspuis si vous voulez imprimer la sortie de f sur une chaîne donnéeputStr$f"Programming Puzzles\n&\nCode Golf"

Edit: Merci à nimi pour 34 octets, excellent travail! :RÉ

— basile-henry
source
Deux choses: La dernière version du Prélude comprend une version infix de map: <$>. replicate(...)' 'peut être remplacé par [1.. ...]>>" ". Dans l' ensemble: unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q].
— nimi
Ah oui, je me souviens que vous ayez mentionné la nouvelle infixe dans une précédente soumission. Comment fonctionne la réplique?
— basile-henry
l1 >> l2fait (longueur l1) des copies de l2 et les concatène. Par exemple "abcd" >> [1,2]-> [1,2,1,2,1,2,1,2](<- 4 copies de 1,2 dans une seule liste). Dans notre cas, il [1..n]>>" "s’agit de n copies d’un espace identique à ce que l’on replicatefait.
— nimi
Nice, merci pour l'explication! :)
— basile-henry
2

R, 126 octets

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

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

Il existe probablement de meilleures façons de le faire tout en y travaillant.

— Mutador
source
1

Gema, 160 octets

\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

Écrit principalement pour ma curiosité de voir ce qui peut être fait dans une langue sans structure de tableau appropriée ni instruction de boucle appropriée.

Échantillon échantillon:

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
— homme au travail
source
1

Perl 6 , 61 octets

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

usage: 

$ perl6 -e '$/=(my@l=lines)».chars.max;for @l {put " "x($/-.chars)/2~$_}' <<< \
'Programming Puzzles
&
Code Golf'
Programming Puzzles
         &
     Code Golf
— Brad Gilbert b2gills
source
Perl 5 vous permettrait de supprimer les espaces dans des choses telles que le for @l {rasage de 2 octets, et de changer put " "en put" "un autre octet. Est-ce vrai pour Perl 6? (Je ne connais pas Perl 6.) De plus, votre sortie telle qu'affichée ici ne correspond pas à la sortie requise; est-ce une faute de frappe?
— msh210
@ msh210 Perl 6 est un peu plus restrictif avec sa syntaxe. Cela compense plus que cela dans d’autres domaines.
— Brad Gilbert b2gills
1

Japt, 28 25

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

Essayez-le en ligne!

Comment ça marche

¡     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
source
0

PHP , 98 octets

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

Essayez-le en ligne!

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

Sortie:

Programming Puzzles
         &         
     Code Golf
— 640 Ko
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.