द बानाच-टार्स्की विरोधाभास

Question

Banach – Tarski विरोधाभास में कहा गया है कि, 3, आयामी अंतरिक्ष में एक गेंद को देखते हुए, आप गेंद को बिंदु उपसमुच्चय की परिमित संख्या में विघटित कर सकते हैं। बिंदुओं के ये निराशाजनक सेट फिर प्रारंभिक गेंद की दो प्रतियों का उत्पादन करने के लिए आश्वस्त किए जा सकते हैं। फिर, सैद्धांतिक रूप से, आपके पास दो समान गेंदें होंगी।

पुनर्मूल्यांकन की प्रक्रिया में केवल उपर्युक्त बिंदु उप-बिंदुओं को स्थानांतरित करना और उन्हें घुमाना होता है, जबकि उनके स्थानिक आकार को बदलना नहीं। यह पाँच के रूप में कुछ के रूप में किया जा सकता है पांच उपसमूह।

Disjoint सेट की परिभाषा के अनुसार कोई सामान्य तत्व नहीं है। आरंभिक गेंद के दो बिंदु उप-समूह कहाँ Aऔर कहाँ Bहैं, इसके बीच के सामान्य तत्व हैं Aऔर Bएक खाली सेट है। यह निम्नलिखित समीकरण में दिखाया गया है।

नीचे दिए गए डिस्गॉइंट सेट के लिए, सामान्य सदस्य एक खाली सेट बनाते हैं।

---

चुनौती

एक प्रोग्राम लिखें जो एक इनपुट ASCII "बॉल" ले सकता है, और एक डुप्लिकेट "बॉल" आउटपुट कर सकता है।

---

इनपुट

यहाँ एक उदाहरण इनपुट बॉल है:

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

प्रत्येक क्षेत्र पाउंड के संकेत द्वारा उल्लिखित है ( #) और किसी भी चीज के पात्रों से भरा हुआ है .,?*&$@!%:। प्रत्येक इनपुट 22x10 वर्ण (ऊंचाई से चौड़ाई) होगा।

---

डुप्लिकेट बनाना

सबसे पहले, गेंद के अंदर प्रत्येक बिंदु को उसके सूचकांक के आधार पर एक अंक दिया जाता है .,?*&$@!%। यहाँ ऊपर उदाहरण दिया गया है, एक बार गिने जाने पर:

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

फिर, प्रत्येक बिंदु को एक में बदल दिया जाता है (नौ एक में चला जाता है):

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

अंत में, प्रत्येक नए बिंदु मान को उसके संबंधित वर्ण में बदल दिया जाता है:

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

---

उत्पादन

इन दो गेंदों को फिर इस तरह से आउटपुट-बाय-साइड किया जाता है, (भूमध्य रेखा पर चार स्थानों द्वारा अलग किया जाता है):

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

---

^{नोट: बिंदु मानों और बाद के वर्णों को स्थानांतरित करना, बिंदु सबसेट्स (वर्ण समूह) को पुन: एकत्रित करने के लिए किए गए घुमावों का प्रतीक है।}

Comments

क्या यह आसन्न होना है? क्या वे एक दूसरे के ऊपर आउटपुट हो सकते हैं?

— ममद सिप

वे आसन्न होना चाहिए। दो 22x10 ब्लॉक को 4 स्थानों से क्षैतिज रूप से अलग किया जाना चाहिए। @Mdd

— Zach गेट्स

आपके कार्यक्रम में कार्य करने की अनुमति है। कार्यक्रम को अपने दम पर निष्पादित करना होगा, हालांकि (उपयोगकर्ता इनपुट के साथ)। @ETHproductions

— Zach गेट्स

दोनों गेंदों को घुमाया नहीं जाना चाहिए? जैसा कि मैं समझता हूं कि प्रमेय, मूल नहीं रहता है, लेकिन आपको दो नई गेंदें मिलती हैं।

— पाओलो एबरमन

हां, लेकिन एक जवाब प्रस्तुत किया गया था इससे पहले कि मुझे वह संपादन करने का मौका मिले, और मैं किसी भी समाधान को अमान्य नहीं करना चाहता था। @ Pa @loEbermann

— Zach गेट्स

Answer 1

पायथ, 21 बाइट्स

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

इसे ऑनलाइन आज़माएँ: प्रदर्शन

अंत में के लिए एक उपयोग के मामले में .r।

व्याख्या

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

अनंत लूप टूट जाता है, जब कोई और इनपुट उपलब्ध नहीं होता है।

Answer 2

रूबी, ६५

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

जब स्टडिन के बजाय इनपुट फ़ाइल से लिया जाता है तो बढ़िया काम करता है:

ruby banach.rb < ball.txt

दूसरी ओर, यदि आप मैन्युअल रूप से स्टड करने के लिए गेंदों में टाइप करना पसंद करते हैं, और अंत में आउटपुट चाहते हैं, तो इस 67-बाइट संस्करण का प्रयास करें:

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

Answer 3

मतलाब, 120

स्ट्रिंग्स को संभालने के लिए मतलाब सबसे बड़ी भाषा नहीं है। \nहमेशा दो वर्णों के रूप में माना जाता है, जो काफी कष्टप्रद है, और आप केवल एक लाइन-ब्रेक-आउट (पंक्ति-टूटी?) स्ट्रिंग से एक मैट्रिक्स नहीं बना सकते हैं, आपको इसे मैन्युअल रूप से करना होगा। कम से कम मुझे आकार / पैडिंग के बारे में परवाह करने की ज़रूरत नहीं थी क्योंकि हर पंक्ति की लंबाई समान है।

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

उदाहरण इनपुट:

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

उदाहरण आउटपुट:

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

पुनश्च: यदि मैं इस तरह से इनपुट ग्रहण कर सकता हूं:

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

मुझे केवल 88 वर्ण चाहिए:

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

Answer 4

रूबी, 102

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

मूल रूप से, यह सिर्फ trइनपुट पर बुला रहा है

Answer 5

सीड (39 बाइट्स)

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

Answer 6

सीजेएम, 28 बाइट्स

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

इसे ऑनलाइन आज़माएं

स्पष्टीकरण:

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.

Answer 7

पायथन 3.5, 96 89 88 बाइट्स

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

पायथन 3.3, 103 96 95 बाइट्स

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

व्याख्या

पायथन 3.3 और 3.5 को अलग-अलग सूचीबद्ध किया गया है क्योंकि जिस तरह से input()आईडीएलई में नए बदलाव आए हैं । यह 8 बाइट्स को बचाने के लिए हुआ, जो शांत है।

निष्पादन पर ध्यान दें: IDLE का उपयोग करें। यदि आप एक टर्मिनल का उपयोग करते हैं, तो 3.3 के लिए समाधान 3.5 के समान है, लेकिन दोनों आउटपुट के साथ इनपुट को इंटरलेव करते हैं।

मैंने sपायथन की नकारात्मक अनुक्रमण का लाभ उठाने के लिए प्रतीक स्ट्रिंग को उलट दिया । फिर इनपुट में प्रत्येक पंक्ति के लिए, मैं इसे आउटपुट करता हूं, दो रिक्त स्थान, और प्रत्येक प्रतीक के साथ पंक्ति इसके पूर्ववर्ती प्रतीक के साथ बदल दी जाती है। कारण मैं केवल दो रिक्त स्थान डाल कि मैं प्रयोग किया जाता है ,के बजाय +, जो मुद्रित आउटपुट के लिए एक जगह कहते हैं। इस ( ,' ',) ने मुझे एक बाइट से बचाया +' '*4+।

मुझे 7 8 बाइट बचाने के लिए xsot का धन्यवाद । मैं मुझे रिक्त स्थान और हैश लगाने की अनुमति देने के s.findलिए बदल s.rfindगया s, जिससे मुझे चेक करने की आवश्यकता को हटा दिया गया y in s। साथ ही, एक स्थान बचाया गया था। संपादित करें: वापस बदल गया s.findक्योंकि ##अब की उपस्थिति मुझे +1इंडेक्स-आउट-ऑफ-बाउंड त्रुटि के बारे में चिंता किए बिना अनुमति देता है ।

Comments

क्या आप बताएंगे कि कैसे input()बदला? मैं 3.4 और 3.5 प्रलेखन के बीच कोई अंतर नहीं पा सकता हूं ।

— केविन

इनपुट स्ट्रिंग में नई लिंक इनपुट को "समाप्त" करती है, इसलिए अपने इनपुट कोड को बोलने और फिर से कॉल करने के लिए। पाइथन 3.3 में, नए अंक बरकरार हैं। परिवर्तन 3.3 और 3.4 के बीच होना चाहिए।

— एल'एंडिया स्ट्रैटन

नहीं, 3.3 डॉक्स समान हैं। मुझे लगता है कि यह एक बदलाव है, शायद एक संस्करण टक्कर से। यदि आप रीडलाइन के बिना संकलन करते हैं, तो आपको कोई अंतर नजर नहीं आता।

— केविन

मैं IDLE का उपयोग करता हूं, इसलिए यह गलती पर भी हो सकता है। मैं इसे एक टर्मिनल से चलाने की कोशिश करूँगा।

— एल'एंडिया स्ट्रैटन

@ केविन: कितना दिलचस्प है। कमांड लाइन से, यह 3.5 में ठीक से काम करता है, हालांकि इनपुट आउटपुट के साथ इंटरलीव्ड है । 3.3 के लिए, यह पहली न्यूलाइन के तुरंत बाद टूट जाता है। मैंने पूरे पाठ को कॉपी-पेस्ट किया।

— एल'एंडिया स्ट्रैटन

Answer 8

रेटिना , 45 39 बाइट्स

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

किसी एकल फ़ाइल से कोड को चलाने के लिए, का उपयोग करें -s ध्वज का ।

पहला चरण प्रत्येक पंक्ति को डुप्लिकेट करता है " ; ", जिसे पाने के लिए अलग किया जाता है

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

फिर दूसरा चरण केवल उन वर्णों को प्रभावित करता है, जो ;.*प्रत्येक पंक्ति के केवल दूसरे भाग के मैचों में पाए जाते हैं । उन वर्णों को फिर निम्नलिखित पत्राचार के माध्यम से दोहराया जाता है

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

जहां पहले 9 जोड़े गेंद में पात्रों को "वृद्धि" करते हैं और अंतिम जोड़ी अर्धविराम को दूसरे स्थान में बदल देती है।

Answer 9

पायथन 2, 77 बाइट्स

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

Answer 10

पर्ल, 59 बाइट्स

56 बाइट्स कोड प्लस 3 बाइट्स के -pरूप में इस के लिए एक फ़ाइल को बचाया जाना चाहिए।

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

उदाहरण का उपयोग:

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

Answer 11

05AB1E (विरासत) , 21 बाइट्स

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

05AB1E की विरासत संस्करण का उपयोग करता है, क्योंकि प्रिंट के लिए फ़र्क के रूप में ʒनिहित के साथ फिल्टर का उपयोग करना संभव था y, जबकि नए संस्करण के vसाथ स्पष्ट प्रत्येक के लिए वास्तविक लूप का yउपयोग किया जाना चाहिए, जो 1 बाइट लंबा है।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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

---

यहां एक संस्करण जो 05AB1E के नए संस्करण ( @Grimy के लिए क्रेडिट ) में भी काम करता है :

05AB1E , 21 बाइट्स

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

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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

Comments

गैर-विरासत 21: TFD?4ú".,?*&$@!%"DÀ‡,(इनपुट बिल्कुल 10 लाइनों की गारंटी है)।

— ग्रैमी

@Grimy इसे भी जोड़ देगा। यह भी पाया गया कि ₂jयह एक अच्छा (हालांकि एक ही बाइट) विकल्प है 4ú, क्योंकि चौड़ाई 26 वर्ण होने की गारंटी है। :)

— केविन क्रूज़सेन