La paradoja de Banach-Tarski establece que, dada una pelota en un espacio tridimensional, puede descomponer la pelota en un número finito de subconjuntos de puntos. Estos conjuntos de puntos disjuntos se pueden volver a montar para producir dos copias de la bola inicial. Entonces, teóricamente, tendrías dos bolas idénticas.

El proceso de reensamblaje consiste en mover solo los subconjuntos de puntos antes mencionados y rotarlos, sin cambiar su forma espacial. Esto se puede hacer con tan solo cinco subconjuntos disjuntos.

Los conjuntos disjuntos no tienen elementos comunes por definición. Donde Ay Bson dos subconjuntos de puntos de la bola inicial, los elementos comunes entre Ay Bes un conjunto vacío. Esto se muestra en la siguiente ecuación.

Para los conjuntos disjuntos a continuación, los miembros comunes forman un conjunto vacío.

El reto

Escriba un programa que pueda tomar una "bola" ASCII de entrada y generar una "bola" duplicada.

Entrada

Aquí hay un ejemplo de bola de entrada:

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

Cada esfera se describe por signos de número ( #) y se llena con cualquiera de las tesis caracteres: .,?*&$@!%. Cada entrada tendrá 22x10 caracteres (ancho por alto).

Crear un duplicado

Primero, cada punto dentro de la pelota recibe un punto numerado basado en su índice .,?*&$@!%. Aquí está el ejemplo anterior, una vez numerado:

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

Luego, cada punto se desplaza uno hacia arriba (nueve va a uno):

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

Finalmente, cada nuevo valor de punto se convierte nuevamente a su carácter correspondiente:

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

Salida

Estas dos bolas se emiten de lado a lado, en esta forma (separadas por cuatro espacios en los ecuadores):

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

^{Nota: Cambiar los valores de los puntos y los caracteres posteriores es simbólico de las rotaciones realizadas para reensamblar los subconjuntos de puntos (agrupaciones de caracteres).}

Pyth, 21 bytes

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

Pruébalo en línea: demostración

Finalmente un caso de uso para .r .

Explicación

#++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

El bucle infinito se rompe, cuando no hay más entradas disponibles.

Rubí, 65

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

Funciona muy bien cuando la entrada se toma de un archivo en lugar de stdin:

ruby banach.rb < ball.txt

Por otro lado, si te gusta escribir bolas para stdin manualmente, y quieres la salida al final, prueba esta versión de 67 bytes:

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

Matlab, 120

Matlab no es el mejor lenguaje para manejar cadenas. \nsiempre se considera como dos caracteres, lo cual es bastante molesto, y no puede simplemente hacer una matriz a partir de una cadena de línea interrumpida (¿línea rota?), tiene que hacerlo manualmente. Al menos no tuve que preocuparme por el tamaño / relleno ya que cada línea tiene exactamente la misma longitud.

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

Entrada de ejemplo:

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

Salida de ejemplo:

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

PD: si puedo asumir la entrada de esta manera:

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

Solo necesito 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('.,?*&$@!%',',?*&$@!%.')}"}

Básicamente, solo está llamando tra la entrada

sed (39 bytes)

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

CJam, 28 bytes

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

Pruébalo en línea

Explicación:

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

Explicación

Python 3.3 y 3.5 se enumeran por separado porque la forma input()maneja las nuevas líneas en IDLE cambió. Esto sucedió para ahorrar 8 bytes, lo cual es genial.

Nota sobre la ejecución: use IDLE.Si usa un terminal, entonces la solución para 3.3 es la misma que 3.5, pero ambas intercalan la entrada con la salida.

Invertí la cadena del símbolo s para aprovechar la indexación negativa de Python. Luego, para cada línea en la entrada, la saco, dos espacios, y la línea con cada símbolo reemplazado por su símbolo anterior. La razón por la que solo puse dos espacios es que usé en ,lugar de +, lo que agrega un espacio a la salida impresa. Esto ( ,' ',) me ahorró un byte +' '*4+.

Gracias a xsot por salvarme 7 8 bytes. Cambié s.finda s.rfindpara permitirme colocar los espacios y los hashes s, eliminando así la necesidad de hacer una verificación y in s. Además, se guardó un espacio. EDITAR: cambió de nuevo a s.findporque la presencia de ##ahora me permite+1 sin preocuparme por un error de índice fuera de límites.

Retina , 45 39 bytes

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

Para ejecutar el código desde un solo archivo, use el -s bandera.

La primera etapa duplica cada línea, separada por " ; ", para obtener

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

Luego, la segunda etapa solo afecta a los caracteres que se encuentran en coincidencias de ;.*, es decir, solo la segunda mitad de cada línea. Esos caracteres se transliteran a través de la siguiente correspondencia

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

Donde los primeros 9 pares "incrementan" los caracteres en la bola y el último par convierte el punto y coma en otro espacio.

Python 2, 77 bytes

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

Perl, 59 bytes

Código de 56 bytes más 3 bytes -pya que esto debe guardarse en un archivo.

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

Ejemplo de uso:

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

05AB1E (heredado) , 21 bytes

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

Utiliza la versión heredada de 05AB1E, porque fue posible usar el filtro ʒcon implícito ycomo foreach para imprimir, mientras que con la nueva versión el bucle real para cada bucle vexplícitoy debe usar el , que es 1 byte más largo.

Pruébalo en línea.

Explicación:

|                      # 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

Aquí una versión que también funciona en la nueva versión de 05AB1E (crédito a @Grimy ):

05AB1E , 21 bytes

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

Pruébalo en línea.

Explicación:

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