Le paradoxe de Banach – Tarski stipule que, étant donné une balle dans un espace tridimensionnel, vous pouvez décomposer la balle en un nombre fini de sous-ensembles de points. Ces ensembles de points disjoints peuvent ensuite être réassemblés pour produire deux copies de la balle initiale. Vous auriez alors, théoriquement, deux boules identiques.

Le processus de réassemblage consiste à déplacer uniquement les sous-ensembles de points susmentionnés et à les faire pivoter, sans modifier leur forme spatiale. Cela peut être fait avec seulement cinq sous-ensembles disjoints.

Les ensembles disjoints n'ont par définition aucun élément commun. Où Aet Bsont deux sous-ensembles de points de la balle initiale, les éléments communs entre Aet Bsont un ensemble vide. Ceci est illustré dans l'équation suivante.

Pour les ensembles disjoints ci-dessous, les membres communs forment un ensemble vide.

Le défi

Écrivez un programme qui peut prendre une "boule" ASCII en entrée et sortir une "boule" en double.

Contribution

Voici un exemple de boule d'entrée:

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

Chaque sphère est décrite par le signe dièse ( #) et rempli avec l' une des thèses caractères: .,?*&$@!%. Chaque entrée sera de 22x10 caractères (largeur par hauteur).

Création d'un doublon

Tout d'abord, chaque point à l'intérieur de la balle reçoit un point numéroté en fonction de son index dans .,?*&$@!%. Voici l'exemple ci-dessus, une fois numéroté:

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

Ensuite, chaque point est décalé d'un (neuf contre un):

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

Enfin, chaque nouvelle valeur de point est reconvertie en son caractère correspondant:

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

Production

Ces deux boules sont ensuite sorties côte à côte, sous cette forme (séparées par quatre espaces aux équateurs):

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

^{Remarque: Le décalage des valeurs des points et des caractères ultérieurs est symbolique des rotations effectuées pour réassembler les sous-ensembles de points (regroupements de caractères).}

Pyth, 21 octets

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

Essayez-le en ligne: Démonstration

Enfin un cas d'utilisation pour .r .

Explication

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

La boucle infinie se casse, lorsqu'il n'y a plus d'entrée disponible.

Rubis, 65

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

Fonctionne très bien lorsque l'entrée provient d'un fichier au lieu de stdin:

ruby banach.rb < ball.txt

D'un autre côté, si vous aimez taper des boules pour stdin manuellement et que vous voulez la sortie à la fin, essayez cette version de 67 octets:

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

Matlab, 120

Matlab n'est pas le meilleur langage pour gérer les chaînes. \nest toujours considéré comme deux caractères, ce qui est assez ennuyeux, et vous ne pouvez pas simplement créer une matrice à partir d'une chaîne à saut de ligne (ligne cassée?), vous devez le faire manuellement. Au moins, je n'ai pas eu à me soucier de la taille / du rembourrage car chaque ligne a exactement la même longueur.

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

Exemple d'entrée:

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

Exemple de sortie:

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

PS: Si je peux assumer l'entrée de cette façon:

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

Je n'ai besoin que de 88 caractères:

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

Rubis, 102

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

Fondamentalement, c'est juste appeler trl'entrée

sed (39 octets)

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

CJam, 28 octets

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

Essayez-le en ligne

Explication:

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 octets

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 octets

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

Explication

Python 3.3 et 3.5 sont répertoriés séparément car la façon dont input()les nouvelles lignes sont traitées dans IDLE a changé. Cela s'est produit pour économiser 8 octets, ce qui est cool.

Remarque sur l'exécution: utilisez IDLE. Si vous utilisez un terminal, alors la solution pour 3.3 est la même que 3.5, mais les deux entrelacent l'entrée avec la sortie.

J'ai inversé la chaîne de symboles spour profiter de l'indexation négative de Python. Ensuite, pour chaque ligne de l'entrée, je la renvoie, deux espaces, et la ligne avec chaque symbole remplacé par son symbole précédent. La raison pour laquelle je ne mets que deux espaces est que j'ai utilisé à la ,place de +, ce qui ajoute un espace à la sortie imprimée. Cela ( ,' ',) m'a sauvé un octet +' '*4+.

Merci à xsot de m'avoir sauvé 7 8 octets. J'ai changé s.findpour s.rfindme permettre de mettre les espaces et les hachages dedans s, supprimant ainsi la nécessité de vérifier y in s. De plus, un espace a été économisé. EDIT: changé en arrière s.findcar la présence de ##now me permet de ne pas me +1soucier d'une erreur d'index hors limites.

Rétine , 45 39 octets

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

Pour exécuter le code à partir d'un seul fichier, utilisez l' -sindicateur.

La première étape duplique chaque ligne, séparée par " ; ", pour obtenir

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

Ensuite, la deuxième étape n'affecte que les caractères qui se trouvent dans les correspondances de ;.*, c'est-à-dire uniquement la seconde moitié de chaque ligne. Ces caractères sont ensuite translittérés via la correspondance suivante

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

Lorsque les 9 premières paires "incrémentent" les personnages de la balle et la dernière paire transforme le point-virgule en un autre espace.

Python 2, 77 octets

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

Perl, 59 octets

Code de 56 octets plus 3 octets -pcar il doit être enregistré dans un fichier.

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

Exemple d'utilisation:

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

05AB1E (hérité) , 21 octets

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

Utilise la version héritée de 05AB1E, car il était possible d'utiliser le filtre ʒavec implicite ycomme foreach pour imprimer, alors qu'avec la nouvelle version, la boucle réelle pour chaque vavec explicite ydevrait être utilisée, ce qui fait 1 octet de plus.

Essayez-le en ligne.

Explication:

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

Voici une version qui fonctionne également dans la nouvelle version de 05AB1E (crédit à @Grimy ):

05AB1E , 21 octets

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

Essayez-le en ligne.

Explication:

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