Nghịch lý Banach âm Tarski nói rằng, khi cho một quả bóng trong không gian 3 chiều, bạn có thể phân hủy quả bóng thành một số lượng nhỏ các tập con điểm hữu hạn. Những bộ điểm rời rạc này sau đó có thể được ghép lại để tạo ra hai bản sao của quả bóng ban đầu. Về lý thuyết, bạn sẽ có hai quả bóng giống hệt nhau.

Quá trình lắp ráp lại chỉ bao gồm việc di chuyển các tập hợp điểm đã nói ở trên và xoay chúng, trong khi không thay đổi hình dạng không gian của chúng. Điều này có thể được thực hiện với ít nhất năm tập hợp rời rạc.

Các bộ khác nhau không có các yếu tố phổ biến theo định nghĩa. Trong đó Avà Blà bất kỳ tập hợp con hai điểm nào của quả bóng ban đầu, các phần tử phổ biến giữa Avà Blà một tập hợp trống. Điều này được thể hiện trong phương trình sau đây.

Đối với các tập hợp rời rạc bên dưới, các thành viên phổ biến tạo thành một tập hợp trống.

Các thách thức

Viết chương trình có thể lấy "bóng" ASCII đầu vào và xuất ra "bóng" trùng lặp.

Đầu vào

Dưới đây là một quả bóng đầu vào ví dụ:

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

Mỗi hình cầu được phác thảo bằng dấu thăng ( #) và chứa bất kỳ ký tự luận án nào : .,?*&$@!%. Mỗi đầu vào sẽ là 22x10 ký tự (chiều rộng theo chiều cao).

Tạo một bản sao

Đầu tiên, mỗi điểm bên trong quả bóng được cho một điểm được đánh số dựa trên chỉ số của nó .,?*&$@!%. Dưới đây là ví dụ trên, một khi được đánh số:

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

Sau đó, mỗi điểm được chuyển lên một (chín đi đến một):

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

Cuối cùng, mỗi giá trị điểm mới được chuyển đổi trở lại ký tự tương ứng:

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

Đầu ra

Hai quả bóng này sau đó được đặt cạnh nhau, ở dạng này (cách nhau bởi bốn khoảng trắng ở đường xích đạo):

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

^{Lưu ý: Dịch chuyển các giá trị điểm và các ký tự sau này là biểu tượng của các phép quay được thực hiện để ghép lại các tập hợp điểm (nhóm ký tự).}

Bình thường, 21 byte

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

Dùng thử trực tuyến: Trình diễn

Cuối cùng là một trường hợp sử dụng cho .r.

Giải trình

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

Vòng lặp vô hạn phá vỡ, khi không có thêm đầu vào có sẵn.

Ruby, 65

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

Hoạt động tuyệt vời khi đầu vào được lấy từ một tệp thay vì stdin:

ruby banach.rb < ball.txt

Mặt khác, nếu bạn thích gõ bóng vào stdin bằng tay và muốn đầu ra ở cuối, hãy thử phiên bản 67 byte này:

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

Matlab, 120

Matlab không phải là ngôn ngữ tốt nhất để xử lý chuỗi. \nluôn được coi là hai ký tự, điều này khá khó chịu và bạn không thể tạo một ma trận ra khỏi chuỗi bị ngắt dòng (ngắt dòng?), bạn phải thực hiện thủ công. Ít nhất tôi không phải quan tâm đến kích thước / phần đệm vì mỗi dòng có cùng độ dài.

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

Ví dụ đầu vào:

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

Ví dụ đầu ra:

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

PS: Nếu tôi có thể giả sử đầu vào theo cách này:

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

Tôi chỉ cần 88 ký tự:

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

Hồng ngọc, 102

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

Về cơ bản, nó chỉ gọi trvào đầu vào

sed (39 byte)

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

CJam, 28 byte

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

Dùng thử trực tuyến

Giải trình:

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 byte

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 byte

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

Giải trình

Python 3.3 và 3.5 được liệt kê riêng vì cách input()xử lý các dòng mới trong IDLE đã thay đổi. Điều này đã xảy ra để tiết kiệm 8 byte, thật tuyệt.

Lưu ý khi thực hiện: sử dụng IDLE. Nếu bạn sử dụng một thiết bị đầu cuối, thì giải pháp cho 3.3 giống như 3.5, nhưng cả hai đều xen kẽ đầu vào với đầu ra.

Tôi đã đảo ngược chuỗi ký hiệu sđể tận dụng việc lập chỉ mục phủ định của Python. Sau đó, với mỗi dòng trong đầu vào, tôi xuất nó, hai khoảng trắng và dòng với mỗi ký hiệu được thay thế bằng ký hiệu trước đó. Lý do tôi chỉ đặt hai khoảng trắng là tôi đã sử dụng ,thay vì +thêm một khoảng trắng vào đầu ra được in. Điều này ( ,' ',) đã tiết kiệm cho tôi một byte hơn +' '*4+.

Cảm ơn xsot vì đã tiết kiệm cho tôi 7 8 byte. Tôi đã thay đổi s.findđể s.rfindcho phép tôi đặt dấu cách và băm vào s, do đó loại bỏ sự cần thiết phải kiểm tra y in s. Thêm vào đó, một không gian đã được lưu. EDIT: đã thay đổi trở lại s.findbởi vì sự hiện diện của ##bây giờ cho phép tôi +1mà không phải lo lắng về lỗi ngoài chỉ mục.

Võng mạc , 45 39 byte

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

Để chạy mã từ một tệp duy nhất, sử dụng -scờ.

Giai đoạn đầu tiên sao chép từng dòng, cách nhau bởi " ; ", để có được

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

Sau đó, giai đoạn thứ hai chỉ ảnh hưởng đến các ký tự được tìm thấy trong các trận đấu ;.*, tức là chỉ nửa sau của mỗi dòng. Những ký tự này sau đó được phiên âm thông qua sự tương ứng sau đây

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

Trong đó 9 cặp đầu tiên "tăng" các ký tự trong quả bóng và cặp cuối cùng biến dấu chấm phẩy sang một không gian khác.

Python 2, 77 byte

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

Perl, 59 byte

Mã 56 byte cộng với 3 byte -pvì điều này cần được lưu vào một tệp.

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

Ví dụ sử dụng:

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

05AB1E (di sản) , 21 byte

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

Sử dụng phiên bản kế thừa của 05AB1E, vì có thể sử dụng bộ lọc ʒvới ẩn ynhư một hướng dẫn để in, trong khi với phiên bản mới, nên sử dụng vòng lặp thực tế với mỗi vòng lặp vrõ ràng y, dài hơn 1 byte.

Hãy thử trực tuyến.

Giải trình:

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

Tại đây, một phiên bản cũng hoạt động trong phiên bản mới của 05AB1E (ghi có vào @Grimy ):

05AB1E , 21 byte

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

Hãy thử trực tuyến.

Giải trình:

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