Il paradosso di Banach-Tarski afferma che, data una palla nello spazio tridimensionale, è possibile scomporre la palla in un numero finito di sottoinsiemi di punti. Questi insiemi di punti disgiunti possono quindi essere riassemblati per produrre due copie della palla iniziale. Quindi, teoricamente, avresti due palle identiche.

Il processo di riassemblaggio consiste solo nello spostare i sottogruppi di punti sopra menzionati e nel ruotarli, senza cambiare la loro forma spaziale. Questo può essere fatto con un massimo di cinque sottoinsiemi disgiunti.

Gli insiemi disgiunti non hanno elementi comuni per definizione. Dove Ae Bsono due sottoinsiemi di due punti della palla iniziale, gli elementi comuni tra Aed Bè un insieme vuoto. Questo è mostrato nella seguente equazione.

Per i set disgiunti di seguito, i membri comuni formano un set vuoto.

La sfida

Scrivi un programma che può prendere una "palla" di input ASCII e produrre una "palla" duplicata.

Ingresso

Ecco un esempio di input ball:

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

Ogni sfera è delineato da segni di cancelletto ( #) e riempito con una delle tesi caratteri: .,?*&$@!%. Ogni input avrà 22x10 caratteri (larghezza per altezza).

Creazione di un duplicato

Innanzitutto, a ciascun punto all'interno della palla viene assegnato un punto numerato basato sul suo indice in .,?*&$@!%. Ecco l'esempio sopra, una volta numerato:

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

Quindi, ogni punto viene spostato in alto di uno (nove vanno a uno):

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

Infine, ogni nuovo valore in punti viene riconvertito nel carattere corrispondente:

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

Produzione

Queste due sfere vengono quindi emesse fianco a fianco, in questa forma (separate da quattro spazi agli equatori):

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

^{Nota: lo spostamento dei valori dei punti e dei caratteri successivi è simbolico delle rotazioni eseguite per riassemblare i sottoinsiemi di punti (raggruppamenti di caratteri).}

Pyth, 21 byte

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

Provalo online: dimostrazione

Finalmente un caso d'uso per .r.

Spiegazione

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

Il ciclo infinito si interrompe quando non c'è più input disponibile.

Ruby, 65 anni

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

Funziona alla grande quando l'input è preso da un file invece di stdin:

ruby banach.rb < ball.txt

D'altra parte, se ti piace digitare palle per stdin manualmente e vuoi l'output alla fine, prova questa versione da 67 byte:

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

Matlab, 120

Matlab non è il linguaggio migliore per gestire le stringhe. \nè sempre considerato come due caratteri, il che è abbastanza fastidioso, e non puoi semplicemente creare una matrice da una stringa interrotta (interruzione di linea?), devi farlo manualmente. Almeno non dovevo preoccuparmi delle dimensioni / imbottitura poiché ogni linea ha la stessa identica lunghezza.

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

Esempio di input:

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

Esempio di output:

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

PS: se posso assumere l'input in questo modo:

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

Ho solo bisogno di 88 caratteri:

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

Fondamentalmente, è solo chiamando trl'input

sed (39 byte)

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

CJam, 28 byte

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

Provalo online

Spiegazione:

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

Spiegazione

Python 3.3 e 3.5 sono elencati separatamente perché il modo input() gestisce le nuove righe in IDLE è cambiato. Questo è successo per salvare 8 byte, il che è fantastico.

Nota sull'esecuzione: utilizzare IDLE. Se si utilizza un terminale, la soluzione per 3.3 è la stessa di 3.5, ma entrambi interfogliano l'input con l'output.

Ho invertito la stringa di simboli sper sfruttare l'indicizzazione negativa di Python. Quindi per ogni riga nell'input, l'output, due spazi e la riga con ogni simbolo sostituita con il suo simbolo precedente. Il motivo per cui ho inserito solo due spazi è che ho usato al ,posto di +, il che aggiunge uno spazio all'output stampato. Questo (,' ', ) mi ha fatto risparmiare un byte +' '*4+.

Grazie a xsot per avermi salvato 7 8 byte. Ho cambiato s.findper s.rfindconsentirmi di inserire gli spazi e gli hash s, eliminando così la necessità di fare un controllo y in s. Inoltre, è stato salvato uno spazio. EDIT: modificato in s.findperché la presenza di ##now mi permette di farlo +1senza preoccuparmi di un errore di indice fuori limite.

Retina , 45 39 byte

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

Per eseguire il codice da un singolo file, utilizzare il -sflag.

Il primo stadio duplica ogni riga, separata da " ; ", per ottenere

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

Quindi il secondo stadio riguarda solo i personaggi che si trovano nelle partite di ;.*, cioè solo la seconda metà di ogni riga. Questi caratteri vengono quindi traslitterati tramite la seguente corrispondenza

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

Dove le prime 9 coppie "incrementano" i personaggi nella palla e l'ultima coppia trasforma il punto e virgola in un altro spazio.

Python 2, 77 byte

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

Perl, 59 byte

56 byte di codice più 3 byte per in -pquanto questo deve essere salvato in un file.

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

Esempio di utilizzo:

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

05AB1E (legacy) , 21 byte

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

Utilizza la versione legacy di 05AB1E, perché era possibile utilizzare il filtro ʒimplicitamente ycome foreach per la stampa, mentre con la nuova versione l'effettivo ciclo for-each vcon esplicitoy dovrebbe usare , che è 1 byte più lungo.

Provalo online.

Spiegazione:

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

Ecco una versione che funziona anche nella nuova versione di 05AB1E (credito a @Grimy ):

05AB1E , 21 byte

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

Provalo online.

Spiegazione:

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