Faça um super acróstico

35

fundo

Comemorando o lançamento do Dyalog APL 16.0 , onde a solução para esse problema é {⊢⌺(≢⍵)⊢⍵}Explicação

Tarefa

Dada uma cadeia ASCII imprimível de comprimento estranho n , fazer um n x n quadrado com a cadeia centrado horizontalmente, duplicado para ser centrado verticalmente, e com acrostics da mesma cadeia em cada linha e coluna. Observe que todas as cordas, exceto as centradas, serão cortadas para manter o tamanho do quadrado n × n .

A explicação do seu código será muito apreciada.

Regras

  1. Você pode ter espaços em branco e novas linhas à direita (isso inclui o triângulo inferior direito)
  2. Você pode retornar uma lista de strings

Exemplo usando a sequência ABXCD:

  • n é 5. Primeiro, desenhamos as duas cordas centralizadas, uma horizontal e outra vertical:

    ┌─────┐
│ A │
│ B │
│ABXCD│
│ C │
│ D │
└─────┘

    (Caixa delimitadora 5 × 5 adicionada para maior clareza)

  • Em seguida, colocamos todos os acrósticos possíveis, horizontal e verticalmente:

           UMA
      AB
  ┌─────┐
  │ ABX│CD
  │ ABXC│D
  │ABXCD│
 A│BXCD │
AB│XCD │
  └─────┘
   CD
   D

  • Finalmente, retornamos apenas o que está dentro da caixa delimitadora:

      ABX
 ABXC
ABXCD
BXCD 
XCD

Casos de teste

World:

  Wor
 Worl
World
orld
rld

mississippi:

     missis
    mississ
   mississi
  mississip
 mississipp
mississippi
ississippi
ssissippi
sissippi
issippi
ssippi

Pneumonoultramicroscopicsilicovolcanoconiosis:

                      Pneumonoultramicroscopi
                     Pneumonoultramicroscopic
                    Pneumonoultramicroscopics
                   Pneumonoultramicroscopicsi
                  Pneumonoultramicroscopicsil
                 Pneumonoultramicroscopicsili
                Pneumonoultramicroscopicsilic
               Pneumonoultramicroscopicsilico
              Pneumonoultramicroscopicsilicov
             Pneumonoultramicroscopicsilicovo
            Pneumonoultramicroscopicsilicovol
           Pneumonoultramicroscopicsilicovolc
          Pneumonoultramicroscopicsilicovolca
         Pneumonoultramicroscopicsilicovolcan
        Pneumonoultramicroscopicsilicovolcano
       Pneumonoultramicroscopicsilicovolcanoc
      Pneumonoultramicroscopicsilicovolcanoco
     Pneumonoultramicroscopicsilicovolcanocon
    Pneumonoultramicroscopicsilicovolcanoconi
   Pneumonoultramicroscopicsilicovolcanoconio
  Pneumonoultramicroscopicsilicovolcanoconios
 Pneumonoultramicroscopicsilicovolcanoconiosi
Pneumonoultramicroscopicsilicovolcanoconiosis
neumonoultramicroscopicsilicovolcanoconiosis
eumonoultramicroscopicsilicovolcanoconiosis
umonoultramicroscopicsilicovolcanoconiosis
monoultramicroscopicsilicovolcanoconiosis
onoultramicroscopicsilicovolcanoconiosis
noultramicroscopicsilicovolcanoconiosis
oultramicroscopicsilicovolcanoconiosis
ultramicroscopicsilicovolcanoconiosis
ltramicroscopicsilicovolcanoconiosis
tramicroscopicsilicovolcanoconiosis
ramicroscopicsilicovolcanoconiosis
amicroscopicsilicovolcanoconiosis
microscopicsilicovolcanoconiosis
icroscopicsilicovolcanoconiosis
croscopicsilicovolcanoconiosis
roscopicsilicovolcanoconiosis
oscopicsilicovolcanoconiosis
scopicsilicovolcanoconiosis
copicsilicovolcanoconiosis
opicsilicovolcanoconiosis
picsilicovolcanoconiosis
icsilicovolcanoconiosis

Agradecimentos

Obrigado a dzaima , Leaky Nun , Sr. Xcoder por tudo, menos pela própria idéia desse desafio.

code-golf  string 
— Adão
fonte
11
A troca de espaços no canto inferior direito deve ser incluída ou não?
— flawr
11
@flawr OP: pode
— Adám

Respostas:

5

MATL , 8 bytes

nXyPGZ+c

Experimente online!

Explicação

n    % Implicit input. Number of elements
Xy   % Identity matrix of that size
P    % Flip vertically
G    % Push input again
Z+   % 2D convolution, maintaining size
c    % Convert to char (char 0 is displayed as space). Implicitly display
— Luis Mendo
fonte
11
Quem pensou que gostaria desta resposta: D
— flawr
11
@flawr Sim, quem teria pensado #
— Luis Mendo
4

Retina , 70 59 bytes

.
$.'$* $_$.`$* ¶
(?=((....))+)(?<-1>.)+(.*?)(?<-2>.)+¶
$3¶

Experimente online! Editar: salvou 11 bytes com alguma ajuda de @MartinEnder. Explicação: O primeiro estágio repete a entrada uma vez para cada caractere, preenchendo-a adequadamente em cada linha para obter o cisalhamento. O último estágio remove 25% de cada lado para produzir o resultado desejado.

— Neil
fonte
Eu acho que tinha 59 antes. Não tenho tempo para desenterrar os detalhes agora, mas essencialmente no primeiro estágio, apenas preenchi a entrada com n/2espaços à esquerda e à direita (usando algo como (..)+.-> $#1$* $&$#1$*com um espaço à direita) e, em seguida, apenas fiz um !&`...onde ...corresponde nexatamente aos ncaracteres.
— Martin Ender
Sua abordagem pode, pelo menos, ser reduzido para 63: tio.run/##K0otycxL/...
— Martin Ender
@MartinEnder Obrigado, e já joguei mais 4 bytes!
— Neil
Você precisa do segundo $*sp?
— CalculatorFeline
@CalculatorFeline Sim, eu preciso que todas as linhas tenham o mesmo comprimento, para que eu possa dividi-las por 4. #
— Neil
3

Java 8, 120 103 bytes

s->{int l=s.length(),i=l/2;for(;i-->0;s=" "+s+" ");for(;++i<l;System.out.println(s.substring(i,l+i)));}

-17 bytes graças a @ OlivierGrégoire .

Explicação:

Experimente aqui.

s->{                      // Method with String parameter and no return-type
  int l=s.length(),       //  Length of the input-String
      i=l/2;              //  Temp index-integer (starting at halve the length floored)
  for(;i-->0;             //  Loop (1) from `l/2` to 0 (exclusive)
    s=" "+s+" "           //   Add spaces before and after the input-String
  );                      //  End of loop (1)
                          //  (If the input was "World", it is now "  World  ")
  for(;++i<l;             //  Loop (2) from 0 to `l` (exclusive)
    System.out.println(   //   Print:
      s.substring(i,      //    Substring of the modified input from `i`
                    l+i)  //    to `l+i` (exclusive)
    )                     //   End of print
  );                      //  End of loop (2)
}                         // End of method
— Kevin Cruijssen
fonte
i=l/2+1e i-->1e for(;i<lsalvar um byte.
— Olivier Grégoire
11
E ... totalmente jogado: s->{int l=s.length(),i=l/2;while(i-->0)s=" "+s+" ";while(++i<l)System.out.println(s.substring(i,l+i));}(103 bytes). A única mudança significativa é que a string com espaços é gerada de uma vez por todas em vez de "on the fly" (e, claro, a impressão em vez de retornar).
— Olivier Grégoire
3

Haskell, 64 62 bytes

f s|l<-length s=take l$take l<$>scanr(:)""(([2,4..l]>>" ")++s)

Experimente online! Como funciona:

l<-length s               -- let l be the length of the input string

      ([2,4..l]>>" ")     -- take l/2 spaces and
                     ++s  -- append s
    scanr(:)""            -- make a list of the inits of the above string, e.g.
                          -- "  world" -> ["  world"," world","world","orld"...]
  take l <$>              -- take the first l chars of each string
take l                    -- and the first l strings
— nimi
fonte
3

Prolog SWI, 234 bytes

h(_,0,_,_,[]).
h(T,N,S,L,[H|U]):-sub_string(T,S,L,_,H),M is N-1,A is S+1,h(T,M,A,L,U).
s(T,R):-string_length(T,L),findall('_',between(1,L,_),A),string_chars(B,A),
                   string_concat(B,T,C),string_concat(C,B,D),S is L-((L-1)/2),h(D,L,S,L,R).

Talvez tente online aqui: http://swish.swi-prolog.org/p/hEKigfEl.pl

NB.

  1. A última linha é uma linha longa, eu adicionei uma quebra de linha e espaços aqui apenas para evitar a barra de rolagem horizontal nesta resposta.
  2. A questão envolve espaços para preenchimento, mas o Swish on-line não os mostra de maneira limpa por causa das interações de renderização HTML, você deve visualizar o código-fonte nas ferramentas de desenvolvimento do navegador para verificar se estão presentes (estão). Alterei o preenchimento para estar _aqui, pois demonstra que está funcionando e não afeta a contagem de bytes.

Exemplos em execução no Swish:

Casos de teste

Abordagem, basicamente a primeira coisa que eu poderia fazer funcionar, e sem dúvida um usuário qualificado do Prolog poderia reduzi-lo bastante:

  • Dada uma sequência de comprimento L, a saída terá L linhas e cada linha terá L caracteres, então 'L' aparece muito. Contagem regressiva de L a 0 para o número de linhas, L para o comprimento da substring para cada linha.
  • Crie uma sequência de preenchimento com espaços em L (sublinhados), adicione-a nas duas extremidades da sequência de entrada, porque esse é um comprimento simples que definitivamente será preenchimento suficiente.
  • Calcule um deslocamento inicial nessa cadeia de comprimento triplo e recorra, gerando uma substring de cada vez, em uma lista de resultados.

Código explicado e comentado (pode não ser executado), lido superacrostic()abaixo, helper()corpo principal e helper()caso base:

% helper function recursive base case, 
% matches when counter is 0, other input has any values, and empty list 'output'.
helper(_,0,_,_,[]). 



% helper function recursively generates substrings
% matching a padded input Text, a line Counter
% a substring starting Offset, a line Length,
% and an output list with a Head and a Tail
helper(Text, Counter, Offset, LineLength, [Head|Tail]):-

    sub_string(Text, Offset, LineLength, _, Head),    % The list Head matches
                                                      % a substring of Text starting 
                                                      % from Offset, of LineLength chars 
                                                      % and

    NextCounter is Counter-1,                         % decrement the Counter

    NextOffset is Offset+1,                           % increment the offset

    helper(Text, NextCounter, NextOffset, LineLength, Tail).  % Recurse for list Tail



% Result is a superacrostic for an input string Text, if
superacrostic(Text, Result):-
    string_length(Text, Length),                   % Length is length of input, 
                                                   % Text = 'ABXCD', Length = 5
                                                   % and

    findall('_',between(1,Length,_),PaddingList),  % PaddingList is a list of padding
                                                   % chars Length items long, 
                                                   % ['_', '_', '_', '_', '_']
                                                   % and

    string_chars(PaddingString, PaddingChars),     % PaddingString is the string from 
                                                   % joining up that list of chars
                                                   % '_____'
                                                   % and

    string_concat(PaddingString, Text, Temp),      % Temp is Text input with a
                                                   % padding prefix
                                                   % Temp = '_____ABXCD'
                                                   % and

    string_concat(Temp, PaddingString, PaddedText), % PaddedText is Temp with 
                                                    % a padded suffix
                                                    % Temp = '_____ABXCD_____'
                                                    % and


    S is Length - ((Length - 1) / 2),              % Starting offset S for the substring
                                                   % is just past the padding,
                                                   % then half the input length back
                                                   % '_____ABXCD_____'
                                                   %     |
                                                   % to start the first line,
                                                   % and


    helper(PaddedText, Length, S, Length, Result). % Result is the list generated from 
                                                   % the helper function, 

    % to recurse Length times for that many output rows, S starting offset, 
    % Length linelength, and Result 'output'.
— TessellatingHeckler
fonte
2

05AB1E , 11 bytes

g;úIvDIg£,À

Experimente online!

Explicação

g;ú           # prepend len(input)/2 spaces to input
   Iv         # for each char of input do
     D        # duplicate current string
      Ig£     # take the first len(input) chars
         ,    # print
          À   # rotate the string to the left
— Emigna
fonte
2

JavaScript (ES6), 75 bytes

f=(s,k=1,l=s.length)=>k>l?'':(' '.repeat(l)+s).substr(l/2+k,l)+`
`+f(s,k+1)

console.log(f("World"))
Expandir snippet

— Arnauld
fonte
72 bytes . Ou 70 bytes, se você quiser usar o ES8, como eu fiz.
— Shaggy
2

APL (Dyalog Unicode) , 10 caracteres = 22 bytes

{⊢⌺(≢⍵)⊢⍵}

Experimente online!

{… } Função anônima em que o argumento é representado por ⍵

 ⊢ fornecer a área coberta quando

 ⌺(... ) deslizando um estêncil de tamanho

  ≢ Comprimento de

  ⍵ o argumento

 ⊢ em

 ⍵ o argumento

A maneira como isso funciona é permitir que cada caractere forme o meio de uma string com o mesmo comprimento da entrada, preenchendo a esquerda ou a direita conforme necessário. Tome, por exemplo ABXCD:

A sequência tem cinco caracteres, portanto, o estêncil terá uma "abertura" com cinco caracteres de largura.

┌──↓──┐     abertura do estêncil com marcador do meio,
│ ABX│CD   deixe Ano meio
 │ ABXC│D   , B
  │ABXCD|   etc.
  A|BXCD | 
  AB|XCD  |
    └──↑──┘  posição final do estêncil

— Adão
fonte
2

JavaScript (ES8), 66 63 62 bytes

Retorna uma matriz.

s=>[...s].map((_,x)=>s.padStart(l*1.5).substr(x,l),l=s.length)

Tente

o.innerText=(f=
s=>[...s].map((_,x)=>s.padStart(l*1.5).substr(x,l),l=s.length)
)(i.value="Pneumonoultramicroscopicsilicovolcanoconiosis").join`\n`;oninput=_=>o.innerText=f(i.value).join`\n`
<input id=i><pre id=o>
Expandir snippet

Explicação

s=>

Função anônima tomando a string como argumento via parâmetro s.

[...s]

Divida a sequência em uma matriz de caracteres individuais.

l=s.length

Obtenha o comprimento da cadeia e atribua-a à variável l.

.map((_,x)=>                                        )

Mapeie a matriz, passando cada elemento por uma função, onde xestá o índice do elemento atual.

s.padStart(l*1.5)

Para cada elemento, retorne a sequência original com espaços anexados até que o comprimento seja 1,5 vezes o comprimento original.

.substr(x,l)

Obtenha a substring de comprimento lcomeçando no índice do elemento atual.

— Shaggy
fonte
2

V , 14 , 11 bytes

òlÙxHÄ$x>>ê

Experimente online!

3 bytes salvos graças a @nmjmcman!

Hexdump:

00000000: f26c d978 48c4 2478 3e3e ea              .l.xH.$x>>.

Abordagem original (18 bytes):

ø..
Duu@"ñLÙxHÄ$x>

Explicação:

ò           " Recursively:
 l          "   Move one char to the right (this will break the loop if we move too far
  Ù         "   Duplicate this line down
   x        "   Delete the first character on this line
    H       "   Move to the first line
     Ä      "   Duplicate this line up
      $     "   Move to the end of this line
       x    "   And delete a character
        >>  "   Put one space at the beginning of this line
          ê "   And move to this column on the last line
            " (implicit) ò, end the loop.
— DJMcMayhem
fonte
Economize alguns bytes: Experimente online!
— nmjcman101
@ nmjcman101 Ah, isso é genial! Eu esqueci completamente ê. Obrigado :)
— DJMcMayhem
2

Núcleo do PowerShell , 68 bytes

0..($L=($a="$args").Length-1)|%{-join(' '*($L/2)+$a)[($_..($_+$L))]}

Experimente online!

Explicação ungolfed

# Input string ABXCD
# -> indexes  0,1,2,3,4  string indexing and num of output lines.
# -> Pad with half-len of spaces __ABXCD.
# -> sliding window array of chars:
# __ABXCD
# |    |       0..4
#  |    |      1..5
#   |    |     2..6
#    |    |    3..7   (selecting indexes past the end returns $nulls, no error)
#     |    |   4..8

# joining those chars into a line


$Text = "$args"                            # script args array to string.
$L    = $Text.Length - 1                   # useful number

$Offsets = 0..$L                           # range array 0,1,2,3,.. to last offset

$Offsets | ForEach-Object {                # Offsets doubles as number of output lines

    $LinePadding = ' ' * ($L / 2)          # lead padding string __
    $PaddedText  = $LinePadding + $Text    # -> __ABXCD

    $Chars = $_..($_+$L)                   # windows 0..4, then 1..5, then 2..6, etc.
    $Line  = $PaddedText[$Chars]           #_,_,A,B,X then _,A,B,X,C then A,B,X,C,D etc.

    -join $Line                            # __ABX  then _ABXC then ABXCD etc.

}
— TessellatingHeckler
fonte
11
Quer ungolf a junção para [($_..($_+$L))]?
— root
Resposta curta do @root, (não acompanha a junção, ele -join ($Padding + $Text)[0,1,2,3,4]seleciona vários caracteres de uma string acolchoada para uma linha de saída e une-os a uma string para ser uma maneira mais curta de fazer .SubString(). e está gerando o preenchimento no local e o intervalo de caracteres no local. Uma explicação completa do ungolf foi adicionada à minha resposta.
— TessellatingHeckler
2

Japonês , 19 17 14 bytes

Economizou 5 bytes graças a @ETHproductions e @Shaggy

¬£iSp½*Ul¹tYUl

Teste online! -Rsinalizador adicionado para ingressar em novas linhas (fins de visibilidade)

Explicação

¬£iSp½*Ul¹tYUl
                U = Implicit input
¬               Split the input into an array of chars
 £              Map; At each char:
  i               Insert:
   S                Space " "
    p               repeated(
     ½*Ul           .5 * U.length times 
         ¹          )
          t        Substring(
           Y         Index,
            Ul       U.length)
— Oliver
fonte
11
Deveria haver uma maneira muito mais curta de gerar Sp½*Ul, mas não acho que exista um atm ... BTW, você geralmente pode mudar sXX+Ypara tXY( s == .slice, t == .substr)
— ETHproductions
@ETHproductions Oh sim, obrigado!
— Oliver
— Shaggy
Ou, como retornar um array é permitido, 14 bytes .
— Shaggy
1

Gelatina , 11 bytes

LH⁶ẋ;ṫJḣ€LY

Experimente online!

Como funciona

LH⁶ẋ;ṫJḣ€LY   "ABXCD"
L             5
 H            2.5
  ⁶ẋ          "  "
    ;         "  ABXCD"
     ṫJ       ["  ABXCD"
               " ABXCD"
               "ABXCD"
               "BXCD"
               "XCD]
        ḣ€L   ["  ABX"
               " ABXC"
               "ABXCD"
               "BXCD"
               "XCD]
           Y  "  ABX
                ABXC
               ABXCD
               BXCD
               XCD"
— Freira Furada
fonte
1

QBIC , 32 bytes

_L;|A=space$(a'\`2)+A[a|?_sA,b,a

Cara, é hora de eu adicionar space$ao QBIC ...

Explicação

  ;             Read a cmd line parameter as A$
_L |            And take its length as 'a'
A=space$        Set A$ to a number of spaces
(a'\`2)           equal to its own length halved
+A                prepended to itself
[a|             FOR b= 1 to the length of A$
?_sA,b,a        Print a substring of our space-padded A$, starting at the b'th character, running for a chars

Amostra de execução

Command line: acknowledgement
       acknowle
      acknowled
     acknowledg
    acknowledge
   acknowledgem
  acknowledgeme
 acknowledgemen
acknowledgement
cknowledgement
knowledgement
nowledgement
owledgement
wledgement
ledgement
edgement
— steenbergh
fonte
1

Mathematica, 88 bytes

T=Table;Column@Reverse@T[T[" ",i]<>StringDrop[s=#,-i],{i,d=-⌊StringLength@s/2⌋,-d}]&
— J42161217
fonte
1

Haskell , 86 70 bytes

Isso ainda é muito longo, mas obrigado @bartavelle por me lembrar que a saída de uma lista de strings também é aceitável!

f s|m<-div(length s)2=take(2*m+1).(`drop`((*>)s" "++s))<$>[m+1..3*m+1]

Experimente online!

— flawr
fonte
Eu só consegui chegar a 82: experimente online!
— bartavelle
@ bartavelle Isso não parece certo. Seu lado direito não está picado.
— Adám
Sim, eu apresentei um bug! Você pode ganhar um pouco ao cancelar seu contrato: Experimente online!
— bartavelle
E com o corte é 84, tornando sua abordagem melhor! Experimente online!
— #
E você pode economizar muito mais, porque não precisa retornar uma única string; as listas de strings também são boas!
— bartavelle
1

PowerShell , 133 119 bytes

$a="$args";$L=$a.Length;$m=($L+1)/2;$s=" "*($m-1)+$a+" "*($m-1);for($h=0;$h-lt$L;$h++){$r="";0..$L|%{$r+=$s[$_+$h]};$r}

Experimente online!

Ungolfed

$a="$args"
$L=$a.Length                        # the length of the input
$m=($L + 1) / 2                     # the midpoint of the input
$s=" " * ($m-1) + $a + " " * ($m-1) # create a string using the input and padded on both sides with spaces

for($h=0;$h -lt $L;$h++) {          # the height, matching the length of the input
    $r=""                           # init/reset the output string

    0..$L | % {                     # number range to represent each character in the string
        $r+=$s[$_+$h]               # append the output string with the next character
    }

    $r                              # write the output
}
— raiz
fonte
11
Boa resposta! Bem vindo ao site. :)
— DJMcMayhem
1

Python 2 ,76 74 73 bytes

-1 graças a @FelipeNardiBatista

Obviamente, não é tão curto quanto a outra resposta do Python, mas vale a pena tentar um método completamente diferente:

n=input();x=len(n)
for i in range(x):print((2*x-~i)*' '+n)[x+x/2:2*x+x/2]

Experimente online!(com a versão de 74 bytes)

Isso primeiro gera a seqüência completa e, em seguida, a divide para caber no quadrado.

Explicação

n = entrada (); - pega a entrada e a atribui a uma variável n
          x = len (n) - atribui o comprimento da entrada a uma variável x
para i no intervalo (x): - itera no intervalo 0 ... x, com uma variável i
                   print - gera o resultado
                         ((2 * xi-1) * '' + n) - cria a string "diamante"
                                          [x + x / 2: 2 * x + x / 2] - corta a corda para caber na caixa
(2*x+~i)salvar um byte
— Felipe Nardi Batista
@FelipeNardiBatista Thanks.
1

J , 19 bytes

|.!.' '"{~2%~#\-#\.

Experimente online!

Explicação

|.!.' '"{~2%~#\-#\.  Input: string S
             #\      Length of each prefix of S, [1, 2, ..., len(S)]
                #\.  Length of each suffix of S, [len(s), ..., 2, 1]
               -     Subtract elementwise
          2%~        Divide by 2
                     We now have a range [(1-len(S))/2, ..., -1, 0, 1, ..., (len(S)-1)/2]
       "{~           Use each value to operate on S
|.!.' '                Perform a shift while replacing characters with ' '
— milhas
fonte
Funciona ''como substituto.
— FrownyFrog
0

C # (.NET Core) , 101 bytes

(a)=>{int L=a.Length,l=L/2;for(;l-->0;)a=" "+a+" ";for(;++l<L;)Console.WriteLine(a.Substring(l,L));};

Basicamente, a resposta de @ KevinCruijssen. Salva 2 bytes porque string.Lengthnão precisa () e outros 2 bytes porque o segundo argumento string.Substring()é comprimento, em vez de finalizar Índice, mas perde 2 bytes porque Console.WriteLine()é mais longo. Eu tive uma implementação mais ingênua, mas tinha o dobro do tempo, então ...

— Kamil Drakari
fonte
0

Excel VBA, 68 bytes

Golfe

Função de janela imediata VBE anônima que recebe entrada da célula [A1]e sai para a janela imediata VBE

l=[Len(A1)]:For i=Int(-l/2)+2To l/2+1:?Mid(Space(l-i)&[A1],l,l):Next

Ungolfed

Sub C(ByVal s As String)
    Let l = Len(s)
    For i = Int(-l / 2) + 2 To l / 2 + 1 Step 1
        Debug.Print Mid(Space(l - i) & s, l, l)
    Next i
End Sub
— Taylor Scott
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.