Paradoks Banach – Tarski menyatakan bahwa, mengingat bola dalam ruang 3-dimensi, Anda dapat menguraikan bola menjadi sejumlah himpunan bagian himpunan titik yang terbatas. Kumpulan poin yang terpisah ini kemudian dapat disusun kembali untuk menghasilkan dua salinan bola awal. Anda kemudian, secara teoritis, memiliki dua bola yang identik.

Proses reassembly terdiri dari hanya memindahkan himpunan bagian himpunan poin yang disebutkan di atas dan memutarnya, sementara tidak mengubah bentuk spasial mereka. Ini dapat dilakukan dengan sedikitnya lima himpunan bagian yang terpisah.

Set disjoint tidak memiliki elemen umum dengan definisi. Di mana Adan Bapakah ada dua himpunan bagian himpunan bola awal, unsur-unsur umum antara Adan Bmerupakan himpunan kosong. Ini ditunjukkan dalam persamaan berikut.

Untuk set disjoint di bawah ini, anggota biasa membentuk set kosong.

Tantangan

Tulis sebuah program yang dapat mengambil input "ball" ASCII, dan mengeluarkan "ball" duplikat.

Memasukkan

Berikut ini contoh bola input:

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

Setiap sphere diuraikan oleh tanda-tanda pound ( #) dan diisi dengan tesis karakter: .,?*&$@!%. Setiap input akan berukuran 22x10 karakter (lebar dengan tinggi).

Membuat Duplikat

Pertama, setiap titik di dalam bola diberi titik bernomor berdasarkan indeks di .,?*&$@!%. Berikut adalah contoh di atas, setelah diberi nomor:

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

Kemudian, setiap titik digeser ke atas satu (sembilan ke satu):

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

Akhirnya, setiap nilai poin baru dikonversi kembali ke karakter terkait:

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

Keluaran

Kedua bola ini kemudian dikeluarkan berdampingan, dalam bentuk ini (dipisahkan oleh empat spasi di garis katulistiwa):

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

^{Catatan: Menggeser nilai titik, dan karakter yang lebih baru, adalah simbol dari rotasi yang dilakukan untuk memasang kembali subset titik (pengelompokan karakter).}

Pyth, 21 byte

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

Cobalah online: Demonstrasi

Akhirnya sebuah use case untuk .r .

Penjelasan

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

Loop infinite terputus, ketika tidak ada lagi input yang tersedia.

Ruby, 65

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

Berfungsi bagus ketika input diambil dari file alih-alih stdin:

ruby banach.rb < ball.txt

Di sisi lain, jika Anda suka mengetik bola ke stdin secara manual, dan ingin hasilnya di akhir, coba versi 67 byte ini:

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

Matlab, 120

Matlab bukan bahasa terbaik untuk menangani string. \nselalu dianggap sebagai dua karakter, yang cukup menjengkelkan, dan Anda tidak bisa hanya membuat matriks dari string baris-break (line-broken?), Anda harus melakukannya secara manual. Setidaknya saya tidak perlu peduli dengan ukuran / padding karena setiap baris memiliki panjang yang sama persis.

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

Input Contoh:

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

Contoh output:

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

PS: Kalau saya bisa berasumsi input seperti ini:

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

Saya hanya perlu 88 karakter:

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

Pada dasarnya, itu hanya memanggil trinput

sed (39 byte)

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

CJam, 28 byte

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

Cobalah online

Penjelasan:

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

Penjelasan

Python 3.3 dan 3.5 didaftar secara terpisah karena cara input()menangani baris baru di IDLE berubah. Ini terjadi untuk menghemat 8 byte, yang keren.

Catatan tentang eksekusi: gunakan IDLE. Jika Anda menggunakan terminal, maka solusi untuk 3.3 sama dengan 3.5, tetapi keduanya menghubungkan input dengan output.

Saya membalik string simbol suntuk mengambil keuntungan dari pengindeksan negatif Python. Kemudian untuk setiap baris dalam input, saya mengeluarkannya, dua spasi, dan baris dengan masing-masing simbol diganti dengan simbol sebelumnya. Alasan saya hanya menempatkan dua spasi adalah karena saya menggunakan ,alih-alih +, yang menambahkan spasi pada hasil cetakan. Ini ( ,' ',) menyelamatkan saya lebih dari satu byte +' '*4+.

Terima kasih kepada xsot karena telah menyelamatkan saya 7 8 byte. Saya mengubah s.finduntuk s.rfindmengizinkan saya untuk menempatkan spasi dan hash ke dalam s, sehingga menghilangkan kebutuhan untuk melakukan pemeriksaan y in s. Plus, ruang telah disimpan. EDIT: diubah kembali ke s.findkarena kehadiran ##sekarang memungkinkan saya +1tanpa khawatir tentang kesalahan indeks-out-of-bounds.

Retina , 45 39 byte

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

Untuk menjalankan kode dari satu file, gunakan -sbendera.

Tahap pertama menduplikasi setiap baris, dipisahkan oleh " ; ", untuk mendapatkan

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

Kemudian tahap kedua hanya mempengaruhi karakter yang ditemukan dalam pertandingan ;.*, yaitu hanya bagian kedua dari setiap baris. Karakter-karakter tersebut kemudian ditransliterasi melalui korespondensi berikut

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

Di mana 9 pasangan pertama "menambah" karakter dalam bola dan pasangan terakhir mengubah titik koma ke ruang lain.

Python 2, 77 byte

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

Perl, 59 byte

Kode 56 byte ditambah 3 byte karena -pini perlu disimpan ke file.

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

Contoh penggunaan:

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

05AB1E (warisan) , 21 byte

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

Menggunakan versi lawas 05AB1E, karena dimungkinkan untuk menggunakan filter ʒ dengan implisit ysebagai foreach untuk mencetak, sedangkan dengan versi baru yang sebenarnya untuk setiap loop vdengan eksplisit yharus digunakan, yaitu 1 byte lebih lama.

Cobalah online.

Penjelasan:

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

Di sini versi yang juga berfungsi di versi baru 05AB1E (kredit ke @Grimy ):

05AB1E , 21 byte

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

Cobalah online.

Penjelasan:

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