Das Banach-Tarski-Paradoxon besagt, dass Sie bei einer Kugel im dreidimensionalen Raum die Kugel in eine endliche Anzahl von Punkt-Teilmengen zerlegen können. Diese nicht zusammenhängenden Punktmengen können dann wieder zusammengesetzt werden, um zwei Kopien der ursprünglichen Kugel zu erzeugen. Sie hätten dann theoretisch zwei identische Bälle.

Der Vorgang des Zusammenbaus besteht darin, nur die oben genannten Punkt-Teilmengen zu verschieben und sie zu drehen, ohne ihre räumliche Form zu ändern. Dies kann mit nur fünf disjunkten Teilmengen erfolgen.

Disjunkte Mengen haben definitionsgemäß keine gemeinsamen Elemente. Wo Aund Bsind zwei beliebige Punkt-Teilmengen der ursprünglichen Kugel, die gemeinsamen Elemente zwischen Aund Bist eine leere Menge. Dies wird in der folgenden Gleichung gezeigt.

Für die disjunkten Mengen unten bilden die gemeinsamen Mitglieder eine leere Menge.

Die Herausforderung

Schreiben Sie ein Programm, das eine Eingabe-ASCII- "Kugel" und eine doppelte "Kugel" ausgeben kann.

Eingang

Hier ist ein Beispiel für eine Eingabekugel:

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

Jede Kugel wird durch Rauten umrissenen ( #) und mit einem der These Zeichen gefüllt: .,?*&$@!%. Jede Eingabe besteht aus 22x10 Zeichen (Breite nach Höhe).

Ein Duplikat erstellen

Zunächst erhält jeder Punkt innerhalb des Balls einen nummerierten Punkt basierend auf seinem Index in .,?*&$@!%. Hier ist das obige Beispiel, einmal nummeriert:

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

Dann wird jeder Punkt um eins nach oben verschoben (neun geht zu eins):

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

Schließlich wird jeder neue Punktwert wieder in das entsprechende Zeichen umgewandelt:

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

Ausgabe

Diese beiden Bälle werden dann in dieser Form nebeneinander ausgegeben (durch vier Leerzeichen an den Äquatoren getrennt):

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

^{Hinweis: Das Verschieben der Punktwerte und späterer Zeichen ist ein Symbol für die Rotationen, die ausgeführt werden, um die Punktteilmengen (Zeichengruppierungen) wieder zusammenzusetzen.}

Pyth, 21 Bytes

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

Probieren Sie es online aus: Demonstration

Endlich ein Anwendungsfall für .r.

Erläuterung

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

Die Endlosschleife wird unterbrochen, wenn kein Eingang mehr verfügbar ist.

Rubin, 65

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

Funktioniert hervorragend, wenn die Eingabe von einer Datei statt von stdin stammt:

ruby banach.rb < ball.txt

Wenn Sie dagegen Bälle manuell eingeben möchten und die Ausgabe am Ende wünschen, probieren Sie diese 67-Byte-Version aus:

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

Matlab, 120

Matlab ist nicht die beste Sprache für den Umgang mit Strings. \nwird immer als zwei Zeichen betrachtet, was ziemlich ärgerlich ist, und Sie können nicht einfach eine Matrix aus einer Zeichenfolge mit Zeilenumbruch erstellen, sondern müssen dies manuell tun. Zumindest musste ich mich nicht um die Größe / Polsterung kümmern, da jede Linie genau die gleiche Länge hat.

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

Beispiel Eingabe:

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

Beispielausgabe:

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

PS: Wenn ich die Eingabe so annehmen kann:

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

Ich brauche nur 88 Zeichen:

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

Rubin, 102

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

Im Grunde ist es nur trauf den Eingang aufrufen

sed (39 bytes)

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

CJam, 28 Bytes

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

Probieren Sie es online aus

Erläuterung:

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

Erläuterung

Python 3.3 und 3.5 werden separat aufgeführt, da sich die Art und Weise, wie input()Zeilenumbrüche in IDLE behandelt werden, geändert hat. Das hat 8 Bytes gespart, was cool ist.

Hinweis zur Ausführung: IDLE verwenden. Wenn Sie ein Terminal verwenden, ist die Lösung für 3.3 dieselbe wie für 3.5, aber beide verschachteln die Eingabe mit der Ausgabe.

Ich habe die Symbolzeichenfolge umgekehrt s, um die negative Indizierung von Python zu nutzen. Dann gebe ich für jede Zeile in der Eingabe zwei Leerzeichen aus, und die Zeile mit jedem Symbol wird durch das vorangegangene Symbol ersetzt. Der Grund, warum ich nur zwei Leerzeichen eingegeben habe, ist, dass ich ,stattdessen verwendet habe +, wodurch der gedruckten Ausgabe ein Leerzeichen hinzugefügt wird. Dies ( ,' ',) hat mir ein Byte gespart +' '*4+.

Vielen Dank an xsot für das Speichern von 7 bis 8 Bytes. Ich habe geändert s.find, s.rfindum mir zu erlauben, die Leerzeichen und Hashes in zu setzen s, wodurch die Notwendigkeit beseitigt wurde, nach zu suchen y in s. Außerdem wurde ein Platz gespart. BEARBEITEN: Zurückgesetzt auf, s.findweil ##ich mich aufgrund des Vorhandenseins von jetzt nicht mehr +1um einen Indexfehler sorgen muss.

Retina , 45 39 Bytes

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

Verwenden Sie das -sFlag, um den Code aus einer einzelnen Datei auszuführen .

Die erste Stufe dupliziert jede durch getrennte Zeile, um " ; "zu erhalten

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

Dann betrifft die zweite Stufe nur Zeichen, die in Übereinstimmungen von gefunden werden ;.*, dh nur die zweite Hälfte jeder Zeile. Diese Zeichen werden dann über die folgende Korrespondenz transliteriert

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

Wobei die ersten 9 Paare die Zeichen in der Kugel "erhöhen" und das letzte Paar das Semikolon in ein anderes Leerzeichen verwandelt.

Python 2, 77 Bytes

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

Perl, 59 Bytes

56 Byte Code plus 3 Byte, -pda dieser in einer Datei gespeichert werden muss.

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

Anwendungsbeispiel:

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

05AB1E (Legacy) , 21 Byte

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

Verwendet die Vorgängerversion von 05AB1E, da der Filter ʒmit implizit yals foreach zum Drucken verwendet werden konnte, während mit der neuen Version die tatsächliche for-each-Schleife vmit explizit yverwendet werden sollte, die 1 Byte länger ist.

Probieren Sie es online aus.

Erläuterung:

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

Hier eine Version, die auch in der neuen Version von 05AB1E funktioniert ( Dank an @Grimy ):

05AB1E , 21 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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