Centralize o texto!

40

Centralize o texto!

Neste desafio, você estará centralizando várias linhas.

Exemplos

Foo
barbaz

 Foo
barbaz

Hello
World

Hello
World

Programming Puzzles
&
Code Golf

Programming Puzzles
         &
     Code Golf

Especificações

Cada linha de entrada sempre terá pelo menos um caractere que não seja um espaço em branco; você pode assumir que o único caractere de espaço em branco são espaços ( ) e novas linhas. Cada linha de entrada não terá nenhum espaço em branco à direita e / ou à esquerda (exceto a nova linha). O espaço em branco à direita na saída não é permitido.

Você deve estar centralizado na linha mais longa da entrada. Se essa linha tiver um comprimento uniforme, seu programa / função deve preferir centralizar para a esquerda. O comprimento máximo da linha é o que seu idioma pode suportar, mas seu programa deve funcionar em linhas de pelo menos 500.

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Mostrar snippet de código

Este é o código-golfe, pelo que o código mais curto em bytes vence!

code-golf string typography Downgoat
fonte
Nunca haverá mais de um espaço interior?
gato
@cat nunca haverá nenhum espaço em branco à esquerda ou à direita em uma linha (espere pela nova linha, se houver uma) #
Downgoat
sim, mas eu quero dizer espaços internos , como, entre palavras
cat
11
@cat oh, entre palavras, pode haver mais de um espaço em branco. Por exemplo, foo(space)(space)(space)baré uma entrada perfeitamente aceitável
Downgoat
podemos assumir que sempre haverá mais de uma linha?
GamrCorps

Respostas:

15

Pitão, 19 17 bytes

2 bytes graças a Jakube

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

Demonstração

Penso que esta é a primeira vez que a função central .[é útil. O comprimento da linha mais longa é encontrado usando transpose sem truncamento ( .T).

Os espaços à direita são removidos adicionando um caractere não-espaço à frente, removendo os espaços e removendo o caractere adicionado.

isaacg
fonte
11
Provavelmente precisamos de um comprimento máximo na matriz. Isso aparece com muita frequência. +1
Maltysen
As especificações dizem que "Não há espaço em branco à direita na saída". Parece haver espaço em branco à direita em cada linha curta na saída, então não tenho certeza de que conta.
potato
@ Potato Obrigado - que foi adicionado desde que eu respondi.
Isaacg
31

vim, 43 36 35 bytes

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

Bom demais para não postar. Observe a nova linha à direita; é significativo.

Obrigado a @Marth por salvar um personagem!

formato amigável ao vim:

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

Explicação:

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
Maçaneta da porta
fonte
11
Certamente, tudo isso deve ser feito no modo Inserir, certo?
Alex A.
9
@AlexA. Nada disso é feito no modo de inserção. ಠ_ಠ
Maçaneta da
Se você sor!inverter a ordem de classificação, poderá col("$")obter o comprimento da primeira linha (agora a mais longa desde que a ordem seja revertida) em vez de usar G$, economizando um total geral de 1 byte! edit : ou você pode manter a ordem de classificação e usá-la G:let &tw=col("$").
Marth
@Marth Thanks! Eu escolhi o último (sem motivo específico).
Maçaneta
Examinando, :h :sortdescobri que você pode passar uma regex para pular o texto correspondente na classificação, para que você possa :sor /./classificar em tamanho (+4 bytes), o que permite remover os VGrx(-4 bytes) e o segundo desfazer ( -1 bytes). Você também pode usar |separadores em vez de <cr>encadear os comandos, o que permite ignorar o :antes let(-1 bytes) (observe que você precisa usar a sor!solução, Gnão é um comando ex). Portanto :sor! /./|let &tw=col("$")|u|%ce (com um final <CR>) deve salvar 2 bytes.
22415 Marth
23

Mathematica, 96 bytes

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

Não me pergunte como funcionou, eu apenas brinquei com ele até que produzisse a saída correta.

LegionMammal978
fonte
27
+1 para "Não me pergunte como funcionou, eu apenas brinquei com ele até que ele produzisse a saída correta"
cat
4
@cat É assim que faço todo o meu golfe.
lirtosiast
11

Função não competitiva

Esse desafio destacou a grande falta de uma função de "valor máximo" (e valor mínimo) para sequências preguiçosas, então ... eu as adicionei à biblioteca principal (elas são chamadas ⊤ e ⊥, respectivamente). Portanto, não me preocupei em enviar isso como uma resposta em golf (teria que incluir a declaração da função to para ser válida), então aqui está apenas o programa principal.

Execute (function(){$('pre,code').css({lineHeight:5/4,fontFamily:'DejaVu Sans Mono'});})()no console do navegador para obter uma renderização melhor.

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

Explicação

Acredito que esta seja a primeira resposta do Funciton neste site que usa expressões lambda.

  • Primeiro, usamos ǁpara dividir a sequência de entrada nas novas linhas (ASCII 10). Isso retorna uma sequência lenta.
  • Passamos essa sequência por ɱ(map), fornecendo uma lambda que calcula o comprimento de cada string e, em seguida, passamos a sequência final ⊤para obter o comprimento da linha mais longa.
  • Nós também passar essa sequência através de um outro ɱ, dando-lhe um lambda que calcula o comprimento de cada cadeia, subtrai o comprimento de linha máximo calculado anteriormente, as clivagens que por 2 (na verdade, deslocar-direita 1), gera que muitos espaços (ASCII 32) e concatena a sequência nesses espaços. (Por razões geométricas, declarei uma ‡função que chama ‼(string concatenada) com os parâmetros revertidos.)
  • Finalmente, usamos ʝpara reunir todas as seqüências de caracteres, usando novas linhas (ASCII 10) como separador.
Timwi
fonte
+1 para ver como isso é incrível e "Isso é 716 caracteres, totalizando 1.508 bytes"
cat
9

Retina , 54 52 bytes

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

Os \ts podem ser substituídos por guias reais, mas eu usei \taqui, porque, caso contrário, o SE converterá as guias em espaços. Observe que há um espaço à esquerda na segunda linha.

Experimente online.

Explicação

A idéia básica é combinar uma linha que seja pelo menos dois caracteres mais curta que a linha mais longa (ou tecnicamente, dois caracteres mais curta que qualquer outra linha) e envolvê-la em dois espaços. Isso é repetido até que não possamos mais encontrar essa linha, o que significa que todas as linhas estão dentro de um caractere de comprimento máximo (onde o único caractere é responsável por diferenças de paridade e garante que essas linhas sejam deslocadas para a esquerda). Centro).

Quanto ao regex real:

^(.)+$

Apenas corresponde a qualquer linha enquanto empurra uma captura no grupo 1para cada personagem.

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

É um lookbehind que corresponde da direita para a esquerda e move o cursor para o início da string, para que a cabeça de impressão interna possa verificar a string inteira. Observe que, devido à falta de uma âncora, a cabeça de impressão pode ser aplicada de qualquer outro lugar, mas isso não cria correspondências adicionais. Sabemos que [^\t]sempre corresponderá a qualquer caractere na string, porque é garantido que a entrada contenha apenas espaços e feeds de linha no que diz respeito a espaço em branco.

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

Este lookahead tenta encontrar uma linha que tenha pelo menos dois caracteres a mais do que a que estamos correspondendo no momento. [^\t]*move-se pela string para poder corresponder a qualquer linha. ^garante que estamos começando do início da linha. ..depois corresponde aos dois caracteres adicionais necessários para a linha mais longa. Agora (?<-1>.)+corresponde a caracteres individuais nessa linha enquanto estiver saltando do grupo 1(observe que .não pode corresponder a um avanço de linha, portanto, isso é restrito a uma linha). Por fim, (?(1)^)afirma que conseguimos esvaziar o grupo inteiro 1. Se a linha for menor que o necessário, isso não será possível, porque não há caracteres suficientes na linha para sair do grupo 1 com frequência suficiente para esvaziá-la.

Martin Ender
fonte
7

Jolf , 3 bytes

Não competitiva, atualize a pergunta de pós-datas.

Experimente aqui! .

pci
pc  center
  i  string input

¯ \ _ (ツ) _ / ¯ Eu pensei que seria uma função útil.

Conor O'Brien
fonte
11
Essa é uma brecha padrão e, embora não seja explicitamente desabilitada, sua forma incorreta, a menos que esteja embutida no idioma que você encontra, não no que você cria.
Elias Benevedes
3
@EliasBenevedes Adicionei o recurso antes do concurso. Frequentemente, não atualizo meu código até que ele se torne 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 salvos graças ao @ edc65 !

Explicação

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

Teste

Mostrar snippet de código

user81655
fonte
.repeataceita e valores trunca não inteiros, assim você não precisa|0
edc65
7

CJam, 26 23 19 bytes

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

Minha primeira vez usando CJam! Quatro bytes salvos graças a Martin Büttner. Experimente online.

Explicação

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
fonte
11
Aqui estão algumas sugestões :)qN/_z,f{1$,m2/S*\N}
Martin Ender
6

LabVIEW, 3 ou 35 Primitivas do LabVIEW

Localiza as linhas até não sobrar nenhuma, calcula quantos espaços adicionar e reúne tudo.

Como alternativa, você pode usar o alinhamento central embutido nos indicadores de corda, mas parece que é trapaça.

Eumel
fonte
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

Obrigado a @xnor por salvar 2 caracteres

exemplo de entrada:

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

saída de exemplo:

Programming Puzzles
         &
     Code Golf

E terminando em segundo lugar com 84 bytes usando str.center () e str.rstrip (obrigado @JF).

def f(s):
 t=s.split('\n')
 for y in t:print y.center(max(len(f)for f in t)).rstrip()
Willem
fonte
Ele não salva caracteres para atribuir lena uma variável que você usa duas vezes - que é igual a 5 caracteres (como range). Além disso, você pode usar mappara a lista comp.
Xnor
@ William, você pode usar str.rstrip()depois de ligar centerpara se livrar do espaço à direita.
JF
Você pode salvar 7 bytes com um programa completo e usando len(max(a,key=len)), veja isso .
ბიმო
5

TeaScript , 24 bytes

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

Loops através de linhas, adiciona floor((max line length - line length) / 2)espaços ao início.

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

Experimente online

Downgoat
fonte
5
Por que minhas respostas continuam sendo negadas? Eu acho que é hora de mudar o nome de usuário / avatar: p
Downgoat
Corrigido em 27/07/2016. : P
user48538
5

PowerShell, 58 67 bytes

até 58 bytes, graças aos comentários 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
  • É preciso uma matriz de seqüências de caracteres como $a, passa por cada sequência com |%{...}.
  • chama o string.padleft()método em cada string, via % -memberatalho, que leva o comprimento desejado da linha final como parâmetro.
    • nós precisamos array_longest_line_length/2 + current_line_length/2
    • a parte final é current_line_length/2->$_.length/2
    • a outra parte está recalculando o comprimento máximo da linha da matriz todas as vezes através do loop, e o faz com um loop aninhado, criando uma matriz de comprimentos de linha, classificando-a e, em seguida, pegando a última.
TessellatingHeckler
fonte
você pode usar Encurtando nomes de propriedades e comprimento de elementos para obter 58 bytes
mazzy
11
@mazzy que é melhor! desde que você não postou como resposta, editei isso na minha resposta com crédito.
TessellatingHeckler 20/03
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)))))

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
fonte
3

HTML, 40 bytes

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

Mostrar snippet de código

O trecho inclui a </xmp>tag porque o visualizador de trechos de código deseja que minhas tags sejam equilibradas.

Neil
fonte
2

MATL , 22 31 bytes

`jtYz~]xXhc4X4H$ZuZ{Zv

Cada linha é inserida com uma linha à direita (ou seja, um enterpressionamento de tecla). Uma linha vazia (duas enterteclas) marca o final da entrada.

Exemplo

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

Explicação

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

Ruby, 76 68 61 bytes

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

Exemplo de execução:

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
homem a trabalhar
fonte
53 bytes:->t{(s=t.split$/).map{|l|l.center s.map(&:size).max}}
daniero
Também tentei o centercaminho primeiro, mas, pelo que entendi, isso por si só quebraria a regra "Não é permitido espaço em branco à direita na saída". Obrigado pela &:sizeparte - eu também tentei isso também, mas certamente tratei de algo em torno da sintaxe.
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 para a função f, a saída não é impressa.

Uso: carregar no intérprete ghci center.hse, em seguida, se você desejar imprimir a saída de f em uma determinada sequênciaputStr$f"Programming Puzzles\n&\nCode Golf"

Edit: Obrigado a nimi por 34 bytes, ótimo trabalho! : D

basile-henry
fonte
Mais duas coisas: A versão mais recente do Prelude inclui uma versão infix de map: <$>. replicate(...)' 'pode ser substituído por [1.. ...]>>" ". Todos em todos: unlines[([1..div(maximum(l<$>q)-l w)2]>>" ")++w|w<-q].
nimi
Ah, sim, lembro que você mencionou o novo infixo do mapa em uma submissão anterior que fiz. Como o truque de replicação funciona?
basile-henry
l1 >> l2faz (comprimento l1) cópias de l2 e concatena-as. Por exemplo "abcd" >> [1,2]-> [1,2,1,2,1,2,1,2](<- 4 cópias de 1,2 em uma única lista). No nosso caso, [1..n]>>" "são n cópias de um espaço igual ao que replicatefaz.
nimi
Bom, obrigado pela explicação! :)
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="")}

destroçado

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

Provavelmente, existem maneiras melhores de fazer isso, ainda trabalhando nisso.

Mutador
fonte
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 minha curiosidade de ver o que pode ser feito em uma linguagem sem estrutura de matriz adequada e instrução de loop adequada.

Exemplo de execução:

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
homem a trabalhar
fonte
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
fonte
O Perl 5 permitiria que você soltasse os espaços em coisas como for @l {raspar 2 bytes e mudar put " "paraput" " , barbear outro byte. Isso é verdade para o Perl 6? (Eu não conheço o Perl 6.) Além disso, sua saída, conforme exibida aqui, não corresponde à saída necessária; isso é um erro de digitação?
Mk210
@ msh210 O Perl 6 é um pouco mais restritivo com sua sintaxe. É mais do que compensar isso em outras áreas.
Brad Gilbert b2gills
1

Japt, 28 25

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

Experimente online!

Como 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.
ETHproductions
fonte
0

PHP , 98 bytes

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

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

Saída:

Programming Puzzles
         &         
     Code Golf
640KB
fonte