O paradoxo de Banach-Tarski afirma que, dada uma bola no espaço tridimensional, você pode decompor a bola em um número finito de subconjuntos de pontos. Esses conjuntos de pontos separados podem ser remontados para produzir duas cópias da bola inicial. Você teria, teoricamente, duas bolas idênticas.

O processo de remontagem consiste apenas em mover os subconjuntos de pontos mencionados acima e girá-los, sem alterar sua forma espacial. Isso pode ser feito com apenas cinco subconjuntos separados.

Conjuntos disjuntos não têm elementos comuns por definição. Onde Ae Bexistem quaisquer subconjuntos de dois pontos da bola inicial, os elementos comuns entre Ae Bé um conjunto vazio. Isso é mostrado na seguinte equação.

Para os conjuntos disjuntos abaixo, os membros comuns formam um conjunto vazio.

O desafio

Escreva um programa que possa receber uma "bola" ASCII de entrada e gerar uma "bola" duplicada.

Entrada

Aqui está um exemplo de bola de entrada:

      ##########      
   ###@%$*.&.%%!###   
  ##!$,%&?,?*?.*@!##  
 ##&**!,$%$@@?@*@&&## 
#@&$?@!%$*%,.?@?.@&@,#
#,..,.$&*?!$$@%%,**&&#
 ##.!?@*.%?!*&$!%&?## 
  ##!&?$?&.!,?!&!%##  
   ###,@$*&@*,%*###   
      ##########      

Cada esfera é delineada por sinais de libra ( #) e encheu-se com qualquer um dos caracteres teses: .,?*&$@!%. Cada entrada será de 22 x 10 caracteres (largura por altura).

Criando uma duplicata

Primeiro, cada ponto dentro da bola recebe um ponto numerado com base em seu índice em .,?*&$@!%. Aqui está o exemplo acima, uma vez numerado:

      ##########      
   ###7964151998###   
  ##86295323431478##  
 ##5448269677374755## 
#75637896492137317572#
#21121654386679924455#
 ##1837419384568953## 
  ##85363518238589##  
   ###2764574294###   
      ##########      

Então, cada ponto é deslocado um (nove vai para um):

      ##########      
   ###8175262119###   
  ##97316434542589##  
 ##6559371788485866## 
#86748917513248428683#
#32232765497781135566#
 ##2948521495679164## 
  ##96474629349691##  
   ###3875685315###   
      ##########      

Finalmente, cada novo valor de ponto é convertido novamente em seu caractere correspondente:

      ##########      
   ###!.@&,$,..%###   
  ##%@?.$*?*&*,&!%##  
 ##$&&%?@.@!!*!&!$$## 
#!$@*!%.@&.?,*!*,!$!?#
#?,,?,@$&*%@@!..?&&$$#
 ##,%*!&,.*%&$@%.$*## 
  ##%$*@*$,%?*%$%.##  
   ###?!@&$!&?.&###   
      ##########      

Resultado

Essas duas bolas são produzidas lado a lado, nesta forma (separadas por quatro espaços nos equadores):

      ##########                ##########      
   ###@%$*.&.%%!###          ###!.@&,$,..%###   
  ##!$,%&?,?*?.*@!##        ##%@?.$*?*&*,&!%##  
 ##&**!,$%$@@?@*@&&##      ##$&&%?@.@!!*!&!$$## 
#@&$?@!%$*%,.?@?.@&@,#    #!$@*!%.@&.?,*!*,!$!?#
#,..,.$&*?!$$@%%,**&&#    #?,,?,@$&*%@@!..?&&$$#
 ##.!?@*.%?!*&$!%&?##      ##,%*!&,.*%&$@%.$*## 
  ##!&?$?&.!,?!&!%##        ##%$*@*$,%?*%$%.##  
   ###,@$*&@*,%*###          ###?!@&$!&?.&###   
      ##########                ##########      

^{Nota: A alteração dos valores dos pontos e dos caracteres posteriores é simbólica das rotações realizadas para remontar os subconjuntos de pontos (agrupamentos de caracteres).}

Pitão, 21 bytes

#++Jw*4d.rJ".,?*&$@!%

Experimente online: Demonstração

Finalmente, um caso de uso para .r .

Explicação

#++Jw*4d.rJ".,?*&$@!%
#                       infinite loop
   Jw                   read a string from input and store it in J
     *4d                4 spaces
        .rJ".,?*&$@!%   rotate the chars of J using this char order
 ++                     combine the 3 strings (J, spaces, rotated) and print

O loop infinito é interrompido quando não há mais entrada disponível.

Ruby, 65

10.times{b=gets;puts b.chop.tr(',?*&$@!%.','.,?*&$@!%')+'    '+b}

Funciona muito bem quando a entrada é obtida de um arquivo em vez de stdin:

ruby banach.rb < ball.txt

Por outro lado, se você gosta de digitar bolas para stdin manualmente e deseja a saída no final, tente esta versão de 67 bytes:

puts (0..9).map{b=gets;b.chop.tr(',?*&$@!%.','.,?*&$@!%')+'    '+b}

Matlab, 120

O Matlab não é o melhor idioma para lidar com strings. \né sempre considerado como dois caracteres, o que é bastante irritante, e você não pode simplesmente criar uma matriz a partir de uma string com quebra de linha (quebra de linha?), você deve fazê-lo manualmente. Pelo menos eu não precisava me preocupar com o tamanho / estofamento, pois cada linha tem exatamente o mesmo comprimento.

a='.,?*&$@!%.';b=input('');b(b>90)=[];b=reshape(b',22,10)';c=b;for k=1:9;c(b==a(k))=a(k+1);end;disp([b,ones(10,4)*32,c])

Exemplo de entrada:

'      ##########      \n   ###@%$*.&.%%!###   \n  ##!$,%&?,?*?.*@!##  \n ##&**!,$%$@@?@*@&&## \n#@&$?@!%$*%,.?@?.@&@,#\n#,..,.$&*?!$$@%%,**&&#\n ##.!?@*.%?!*&$!%&?## \n  ##!&?$?&.!,?!&!%##  \n   ###,@$*&@*,%*###   \n      ##########      '

Exemplo de saída:

      ##########                ##########      
   ###@%$*.&.%%!###          ###!.@&,$,..%###   
  ##!$,%&?,?*?.*@!##        ##%@?.$*?*&*,&!%##  
 ##&**!,$%$@@?@*@&&##      ##$&&%?@.@!!*!&!$$## 
#@&$?@!%$*%,.?@?.@&@,#    #!$@*!%.@&.?,*!*,!$!?#
#,..,.$&*?!$$@%%,**&&#    #?,,?,@$&*%@@!..?&&$$#
 ##.!?@*.%?!*&$!%&?##      ##,%*!&,.*%&$@%.$*## 
  ##!&?$?&.!,?!&!%##        ##%$*@*$,%?*%$%.##  
   ###,@$*&@*,%*###          ###?!@&$!&?.&###   
      ##########                ##########      

PS: Se eu puder assumir a entrada desta maneira:

['      ##########      ','   ###@%$*.&.%%!###   ','  ##!$,%&?,?*?.*@!##  ',' ##&**!,$%$@@?@*@&&## \n#@&$?@!%$*%,.?@?.@&@,#','#,..,.$&*?!$$@%%,**&&#',' ##.!?@*.%?!*&$!%&?## ','  ##!&?$?&.!,?!&!%##  ','   ###,@$*&@*,%*###   ','      ##########      ']

Eu só preciso de 88 caracteres:

a='.,?*&$@!%.';b=input('');c=b;for k=1:9;c(b==a(k))=a(k+1);end;disp([b,ones(10,4)*32,c])

Ruby, 102

IO.readlines(?a).map(&:chomp).each{|x|puts"#{x+' '*x.count(' ')+?\s*4+x.tr('.,?*&$@!%',',?*&$@!%.')}"}

Basicamente, é só chamar tra entrada

sed (39 bytes)

h;y/.,?*&$@!%/,?*&$@!%./;H;x;s/\n/    /

CJam, 28 bytes

qN/{_".,?*&$@!%"_(+erS4*\N}%

Experimente online

Explicação:

qN/     Get input and split into lines.
{       Start loop over lines.
  _       Copy, since we need to output original.
  ".,?*&$@!%"
          List of characters, in order.
  _       Copy list of characters.
  (+      Rotate the list by popping first character and appending it.
  er      Transliterate.
  S4*     Create 4 spaces.
  \       Swap spaces between original and transliteration.
  N       Add newline.
}%      End of loop over lines.

Python 3.5, 96 89 88 bytes

s='.,?*&$@!%.  ##';i=1
while i:i=input();print(i,'  ',''.join(s[s.find(y)+1]for y in i))

Python 3.3, 103 96 95 bytes

s='.,?*&$@!%.  ##'
for i in input().split('\n'):print(i,'  ',''.join(s[s.find(y)+1]for y in i))

Explicação

Python 3.3 e 3.5 são listados separadamente porque a maneira como as input()novas linhas no IDLE foram alteradas. Isso aconteceu para salvar 8 bytes, o que é legal.

Nota sobre a execução: use IDLE.Se você usa um terminal, a solução para 3.3 é a mesma que 3.5, mas ambos intercalam a entrada com a saída.

Invertei a sequência de símbolos spara tirar proveito da indexação negativa do Python. Então, para cada linha na entrada, eu a produzo, dois espaços e a linha com cada símbolo substituída pelo símbolo anterior. O motivo de eu colocar apenas dois espaços é que usei em ,vez de +, o que adiciona um espaço à saída impressa. Isso ( ,' ',) me salvou um byte +' '*4+.

Obrigado ao xsot por me salvar 7 8 bytes. Mudei s.findpara s.rfindpermitir que eu colocasse os espaços e os hashes s, removendo assim a necessidade de fazer uma verificação y in s. Além disso, um espaço foi salvo. EDIT: mudou de volta para, s.findporque a presença do ##now me permite, +1sem me preocupar com um erro de índice fora dos limites.

Retina , 45 39 bytes

.+
$0  ; $0
T`.,?*&$@!%;`,?*&$@!%. `;.*

Para executar o código de um único arquivo, use o -ssinalizador

O primeiro estágio duplica cada linha, separada por " ; ", para obter

      ##########        ;       ##########
   ###@%$*.&.%%!###     ;    ###@%$*.&.%%!###
  ##!$,%&?,?*?.*@!##    ;   ##!$,%&?,?*?.*@!##
 ##&**!,$%$@@?@*@&&##   ;  ##&**!,$%$@@?@*@&&##
#@&$?@!%$*%,.?@?.@&@,#  ; #@&$?@!%$*%,.?@?.@&@,#
#,..,.$&*?!$$@%%,**&&#  ; #,..,.$&*?!$$@%%,**&&#
 ##.!?@*.%?!*&$!%&?##   ;  ##.!?@*.%?!*&$!%&?##
  ##!&?$?&.!,?!&!%##    ;   ##!&?$?&.!,?!&!%##
   ###,@$*&@*,%*###     ;    ###,@$*&@*,%*###
      ##########        ;       ##########

O segundo estágio afeta apenas os caracteres encontrados nas correspondências de ;.*, ou seja, apenas a segunda metade de cada linha. Esses caracteres são transliterados através da seguinte correspondência

.,?*&$@!%;
,?*&$@!%. 

Onde os 9 primeiros pares "incrementam" os caracteres na bola e o último par transforma o ponto e vírgula em outro espaço.

Python 2, 77 bytes

while 1:r=raw_input();print r,'  ',r.translate(' % #@.$   & ? , '*3+'!*'*104)

Perl, 59 bytes

Código de 56 bytes mais 3 bytes, -ppois isso precisa ser salvo em um arquivo.

chop($s=$_);$l=',?*&$@!%';eval"y/.$l/$l./";$_="$s    $_"

Exemplo de uso:

$perl -p ball.pl <<< '      ##########      
>    ###@%$*.&.%%!###   
>   ##!$,%&?,?*?.*@!##  
>  ##&**!,$%$@@?@*@&&## 
> #@&$?@!%$*%,.?@?.@&@,#
> #,..,.$&*?!$$@%%,**&&#
>  ##.!?@*.%?!*&$!%&?## 
>   ##!&?$?&.!,?!&!%##  
>    ###,@$*&@*,%*###   
>       ##########      
> '
      ##########                ##########      
   ###@%$*.&.%%!###          ###!.@&,$,..%###   
  ##!$,%&?,?*?.*@!##        ##%@?.$*?*&*,&!%##  
 ##&**!,$%$@@?@*@&&##      ##$&&%?@.@!!*!&!$$## 
#@&$?@!%$*%,.?@?.@&@,#    #!$@*!%.@&.?,*!*,!$!?#
#,..,.$&*?!$$@%%,**&&#    #?,,?,@$&*%@@!..?&&$$#
 ##.!?@*.%?!*&$!%&?##      ##,%*!&,.*%&$@%.$*## 
  ##!&?$?&.!,?!&!%##        ##%$*@*$,%?*%$%.##  
   ###,@$*&@*,%*###          ###?!@&$!&?.&###   
      ##########                ##########      

05AB1E (herdado) , 21 bytes

|ʒD4ú".,?*&$@!%"DÀ‡«,

Usa a versão herdada de 05AB1E, porque era possível usar o filtro ʒcom implícito ycomo foreach para imprimir, enquanto que com a nova versão o real para cada loop v explícito com explícito ydeve ser usado, com 1 byte a mais.

Experimente online.

Explicação:

|                      # Get the input-lines as list
 ʒ                     # For-each over the lines to print using the filter-builtin:
  D                    #  Duplicate the current line
   4ú                  #  Prepend 4 spaces to this copy
     ".,?*&$@!%"       #  Push this string
                DÀ     #  Duplicate it, and rotate its copy once towards the left
                  ‡    #  Transliterate the space-prepended string with these two strings
                   «   #  Append it to the original duplicated line
                    ,  #  And print with trailing newlines

Aqui uma versão que também funciona na nova versão do 05AB1E (crédito para @Grimy ):

05AB1E , 21 bytes

TFD?4ú".,?*&$@!%"DÀ‡,

Experimente online.

Explicação:

TF                     # Loop 10 times:
  D                    #  Duplicate the (implicit) input-line
   ?                   #  Pop and print the copy without trailing newline
    4ú                 #  Prepend 4 spaces to the input-line
      ".,?*&$@!%"      #  Push this string
                 DÀ    #  Duplicate it, and rotate its copy once towards the left
                   ‡   #  Transliterate the space-prepended string with these two strings
                    ,  #  And print with trailing newlines