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
— 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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.