Paradoks Banacha-Tarskiego stwierdza, że ​​biorąc pod uwagę piłkę w przestrzeni trójwymiarowej, można ją rozłożyć na skończoną liczbę podzbiorów punktowych. Te rozłączne zestawy punktów można następnie ponownie złożyć, aby uzyskać dwie kopie początkowej piłki. Teoretycznie mielibyśmy dwie identyczne piłki.

Proces ponownego montażu polega jedynie na przesunięciu wyżej wymienionych podzestawów punktowych i obróceniu ich, bez zmiany ich kształtu przestrzennego. Można to zrobić za pomocą zaledwie pięciu rozłącznych podzbiorów.

Zestawy rozłączne z definicji nie mają wspólnych elementów. Gdzie Ai gdzie Bsą dowolne dwa podzbiory punktowe początkowej piłki, wspólne elementy pomiędzy Ai Bsą pustym zbiorem. Pokazano to w poniższym równaniu.

Dla poniższych rozłącznych zestawów członkowie wspólni tworzą pusty zestaw.

Wyzwanie

Napisz program, który może pobrać wejściową „kulkę” ASCII i wypisać zduplikowaną „kulkę”.

Wejście

Oto przykładowa kula wejściowa:

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

Każda kula jest opisana przez znaki funta ( #) i wypełnione każdy tez znaków: .,?*&$@!%. Każde wejście będzie mieć 22x10 znaków (szerokość według wysokości).

Tworzenie duplikatu

Po pierwsze, każdy punkt wewnątrz piłki otrzymuje numerowany punkt na podstawie jego indeksu w .,?*&$@!%. Oto powyższy przykład, raz ponumerowany:

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

Następnie każdy punkt jest przesuwany w górę o jeden (dziewięć przechodzi do jednego):

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

Na koniec każda nowa wartość punktowa jest konwertowana z powrotem na odpowiadający jej znak:

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

Wynik

Te dwie kule są następnie wyprowadzane obok siebie, w tej formie (oddzielone czterema spacjami na równikach):

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

^{Uwaga: Przesunięcie wartości punktów i późniejszych znaków symbolizuje obroty wykonane w celu ponownego złożenia podzbiorów punktów (grupowania znaków).}

Pyth, 21 bajtów

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

Wypróbuj online: demonstracja

Wreszcie przypadek użycia dla .r.

Wyjaśnienie

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

Pętla nieskończona pęka, gdy nie ma już dostępnego wejścia.

Ruby, 65

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

Działa świetnie, gdy dane wejściowe są pobierane z pliku zamiast standardowego wejścia:

ruby banach.rb < ball.txt

Z drugiej strony, jeśli lubisz pisać piłki ręcznie, aby uzyskać standardowe wejście, a chcesz, aby dane wyjściowe były na końcu, wypróbuj tę 67-bajtową wersję:

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

Matlab, 120

Matlab nie jest najlepszym językiem do obsługi napisów. \njest zawsze uważany za dwa znaki, co jest dość irytujące i nie można po prostu zrobić macierzy z łańcucha z podziałem linii (linia-linia?), należy to zrobić ręcznie. Przynajmniej nie musiałem dbać o rozmiar / wypełnienie, ponieważ każda linia ma dokładnie taką samą długość.

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

Przykładowe dane wejściowe:

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

Przykładowe dane wyjściowe:

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

PS: Jeśli mogę przyjąć dane wejściowe w ten sposób:

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

Potrzebuję tylko 88 znaków:

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

Zasadniczo po prostu wywołuje trdane wejściowe

sed (39 bajtów)

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

CJam, 28 bajtów

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

Wypróbuj online

Wyjaśnienie:

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 bajtów

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 bajtów

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

Wyjaśnienie

Python 3.3 i 3.5 są wymienione osobno, ponieważ zmienił się sposób input()obsługi znaków nowej linii w IDLE . Zdarzyło się to zaoszczędzić 8 bajtów, co jest fajne.

Uwaga dotycząca wykonania: użyj IDLE. Jeśli używasz terminala, to rozwiązanie dla 3.3 jest takie samo jak 3.5, ale oba przeplatają wejście z wyjściem.

Odwróciłem ciąg symboli, saby skorzystać z ujemnego indeksowania Pythona. Następnie dla każdego wiersza na wejściu wyprowadzam go, dwie spacje, a wiersz z każdym symbolem zastępuje się poprzednim symbolem. Powodem, dla którego wstawiłem tylko dwie spacje, jest to, że użyłem ,zamiast tego +, co dodaje spację do wydruku. To ( ,' ',) uratowało mi bajt +' '*4+.

Dzięki xsot za uratowanie mnie 7 8 bajtów. Zmieniłem s.findna, s.rfindaby umożliwić mi umieszczanie spacji i skrótów s, tym samym eliminując potrzebę sprawdzania y in s. Dodatkowo zaoszczędzono miejsce. EDYCJA: zmieniono z powrotem na, s.findponieważ obecność ##teraz pozwala mi +1bez martwienia się o błąd indeksu poza zakresem.

Siatkówka , 45 39 bajtów

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

Aby uruchomić kod z jednego pliku, użyj -sflagi.

Pierwszy etap powiela każdą linię oddzieloną " ; ", aby uzyskać

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

Następnie drugi etap dotyczy tylko znaków znalezionych w dopasowaniach ;.*, tj. Tylko drugiej połowie każdej linii. Znaki te są następnie transliterowane za pomocą następującej korespondencji

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

Tam, gdzie pierwsze 9 par „zwiększa”, znaki w piłce i ostatnia para zamieniają średnik w inne miejsce.

Python 2, 77 bajtów

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

Perl, 59 bajtów

Kod 56 bajtów plus 3 bajty, -pponieważ należy to zapisać w pliku.

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

Przykładowe użycie:

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

05AB1E (starsza wersja) , 21 bajtów

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

Wykorzystuje starszą wersję 05AB1E, ponieważ możliwe było użycie filtra ʒz niejawnym ydrukiem foreach, podczas gdy w nowej wersji należy użyć rzeczywistej pętli for-express vz jawnym y, która jest dłuższa o 1 bajt.

Wypróbuj online.

Wyjaśnienie:

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

Tutaj wersja, która działa również w nowej wersji 05AB1E (kredyt na @Grimy ):

05AB1E , 21 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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