विस्फोट बिल्लियों!

Question

चुनौती

आप एक प्रोग्राम / फंक्शन बना रहे होंगे n, जिसमें लंबाई का एक स्ट्रिंग इनपुट हो , और:

1. kthअंतरिक्ष के केंद्र में चार्ट को डालता है, जहां k = (n+1)/2। यह आपके ग्राउंड ज़ीरो का स्थान होगा।
2. गैर-व्हाट्सएप चार्ट के बाकी हिस्सों को बेतरतीब ढंग से ग्राउंड जीरो के आसपास व्यवस्थित करता है। चार्ट से पाइथागोरस की दूरी अधिक नहीं होनी चाहिए n।
3. परिणाम को प्रदर्शित करता है।

यदि आपको स्पष्टीकरण की आवश्यकता है, तो नीचे दिए गए उदाहरण देखें।

---

नियम

• मानक खामियों को लागू!
• I / O एक स्ट्रिंग के रूप में होना चाहिए।
• इनपुट हमेशा यह सुनिश्चित करने के लिए अजीब होगा कि आपके पास ग्राउंड ज़ीरो में डालने के लिए एक केंद्रीय चार्ट है।
• प्रत्येक वैध आउटपुट एक गैर-शून्य संभावना के साथ होना चाहिए।

यह कोड-गोल्फ है ; बाइट्स जीत में सबसे छोटा कोड!

---

उदाहरण

इनपुट: qwert

ग्राउंड ज़ीरो से निकलने वाले विस्फोट की सीमाएँ (शेष चिह्नों के लिए x का मान्य स्थान):

     x
  xxxxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
xxxxxexxxxx
 xxxxxxxxx
 xxxxxxxxx
 xxxxxxxxx
  xxxxxxx
     x

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

       t
     r

q    e


      w

Comments

बेतरतीब ढंग से स्थिति का चयन करते हुए, एक चार दूसरे की उसी स्थिति में जा सकता है और इसे अधिलेखित कर सकता है। क्या यह अनुमति है? (मेरा सुझाव: नहीं)

— edc65

आप सही कह रहे हैं: नहीं

— मामा फन रोल

पृथ्वी पर मुझे उड़ाने से इसका क्या लेना-देना है? (मैं वास्तव में शीर्षक की प्रासंगिकता को नहीं समझता ...)

— बिल्ली

@cat यह एक बिल्ली कार्यक्रम का एक संशोधन है, सिवाय इसके कि आप इनपुट में विस्फोट करते हैं।

— मामा फन रोल

थोड़ा सा संबंधित

— Mego

Answer 1

APL (Dyalog Classic) , 68 66 65 63 62 बाइट्स

{⍵@(n⊣¨¨@(⊢≡¨⌽)i[n?≢i←⍸(××n≥*∘.5)+.ר⍨n-⍳s])⊢''⍴⍨s←2⍴1+2×n←≢⍵}

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

{ } अनाम फ़ंक्शन तर्क के साथ ⍵

n←≢⍵चर nलंबाई है

s←2⍴1+2×nचर sपरिणाम का आकार है: 2n + 1 by 2n + 1

''⍴⍨s उस आकृति के साथ रिक्त स्थान का एक वर्ग बनाएँ

A@I⊢Bमैट्रिक्स Aमें (जोड़े) सूचकांकों पर तत्व डालता हैIB

+.ר⍨n-⍳s मैट्रिक्स के केंद्र से दूर की दूरी

(××n≥*∘.5) बूलियन मैट्रिक्स यह दर्शाता है कि वे दूरी गैर-शून्य कहां हैं और ≤n

⍸ बूलियन मैट्रिक्स में 1s के लिए जोड़े को समन्वयित करें

i[n?≢i← ... ] उनमें से n बेतरतीब ढंग से चुनें (कोई डुप्लिकेट नहीं)

n⊣¨¨@(⊢≡¨⌽) केंद्रीय को बदल दें n n

⍵@( ... )⊢ ... रिक्त स्थान के मैट्रिक्स में दिए गए सूचकांकों पर तर्क से चार्ट डालें

Answer 2

जावास्क्रिप्ट (ईएस 6), 211 216 220

1 बाइट बचाया thx @usandfriends संपादित करें

s=>[...s].map((c,i)=>{for(R=_=>Math.random()*h-l|0;x=R(y=R()),!(i-(l/2|0)?x|y&&x*x+y*y<=l*l&g[y+=l][x+=l]<'!':x=y=l););z=[...g[y]],z[x]=c,g[y]=z.join``},l=s.length,g=Array(h=l-~l).fill(' '.repeat(h)))&&g.join`
`

परीक्षा

f=s=>[...s].map((c,i)=>{for(R=_=>Math.random()*h-l|0;x=R(y=R()),!(i-(l/2|0)?x|y&&x*x+y*y<=l*l&g[y+=l][x+=l]<'!':x=y=l););z=[...g[y]],z[x]=c,g[y]=z.join``},l=s.length,g=Array(h=l-~l).fill(' '.repeat(h)))&&g.join`
`

// Less golfed
U=s=>(
  l=s.length,
  h=l-~l, // l+l+1
  g=Array(h).fill(' '.repeat(h)),
  [...s].map((c,i)=>{
    for(R=_=>Math.random()*h-l|0;
        x=R(y=R()), // set x,y to a random value in range -l ... l
        !(i - (l/2|0) // check if at mid point of input string
          ? x|y && // if not, check x and y must not be both 0
            x*x + y*y <= l*l &  // then check position inside the circle of ray L
            g[y+=l][x+=l] < '!' // then add offset L and check if position is not already used 
          : x=y=l // if at midpoint in input string, x and y have fixed value L
         );
       ); // loop until valid position found
    z = [...g[y]];  // modify string at current position: convert to array ...
    z[x] = c;       // ... set element ...
    g[y] = z.join`` // ... back to string
  }),
  g.join`\n`
)  

setInterval(_=>O.textContent=(f(I.value)),1000)

Word <input id=I value='qwert'><pre id=O></pre>

Comments

आपके पास पहले एक अतिरिक्त जगह हैg.map(r=>r.join``)...

— usandfriends

@usandfriends thx मुझे नहीं पता कि मैंने इसे कैसे याद किया

— edc65

के new Date()%h-lबजाय का उपयोग करें Math.random()*h-l|0। यह बाइट्स बचाता है।

— ericw31415

@ ericw31415 का उपयोग केवल 0. यह बाइट्स को भी बचाता है। लेकिन दोनों काम नहीं करेंगे

— edc65

Answer 3

माणिक, 211 207 203 196 अक्षर

4 पात्रों के लिए edc65 के लिए धन्यवाद

->(x){x=x.chars
o,b,c=x.size
l=o*2+1
a=Array.new(l){Array.new l,' '}
a[o][o]=x.delete_at o/2
a[b][c]=x.pop if a[b=rand(l)][c=rand(l)]==' '&&(b-o)**2+(c-o)**2<=o*o while x[0]
a.map(&:join).join $/}

स्पष्टीकरण:

->(x){...} एक अनाम फ़ंक्शन को परिभाषित करें जो एक तर्क में लेता है x

x=x.charsxस्ट्रिंग से एक-वर्ण स्ट्रिंग्स की एक सरणी में बदलना

o,b,c=x.sizeoबाद में उपयोग के लिए इनपुट की लंबाई को स्टोर करें। bऔर cबस किसी चीज़ को इनिशियलाइज़ करने की ज़रूरत है , इसलिए पिछले असाइनमेंट को संलग्न करके 2 अक्षर बचाएं।

l=o*2+1 यह उस क्षेत्र की लंबाई / चौड़ाई है जहां सभी वर्ण संभवतः जा सकते हैं, विस्फोट चक्र का व्यास भी।

Array.new(l){Array.new l,' '}अंतरिक्ष वर्णों का lx lआकार 2D सरणी बनाते हैं ।

a[o][o]=x.delete_at o/2सरणी के केंद्र को x(इनपुट) के मानों के केंद्र में सेट करता है , जबकि उस मान को हटा रहा हैx

... while x[0] ब्लॉक को चलाएं (इस स्थिति में, पहले वाला कोड while क्योंकि यह इनलाइन है) पर और xखाली होने तक । रूबी में, एक सूचकांक का उपयोग करना जो रिटर्न मौजूद नहीं है nil, जो एक गलत मूल्य है।

a[b=rand(l)][c=rand(l)]==' 'असाइन करें bऔर cयादृच्छिक मानों के लिए जहां 0 <= n <l । फिर देखें कि में स्थान b, cरिक्त है (उर्फ अंतरिक्ष चरित्र के लिए सेट है)

(b-o)**2+(c-o)**2<=o*oपाइथागोरस दूरी की जाँच करें। oइनपुट की लंबाई है।**रूबी का प्रतिपादक ऑपरेटर है, और इससे val<=o*oछोटा है val**0.5<=o।

a[b][c]=x.popसे अंतिम मान हटाएं x। स्थिति सेट करेंa , bसरणी में है कि मूल्य के लिएa

a[b][c]=x.pop if a[b=rand(l)][c=rand(l)]==' '&&(b-o)**2+(c-o)**2<=o*o while x[0]अंतिम मान के लिए एक यादृच्छिक स्थिति सेट करें यदि वह स्थिति मुफ़्त है और विस्फोट त्रिज्या के भीतर है; ऐसा तब तक करते रहें जब तक कि हम वर्णों से बाहर नहीं निकल जाते।

$/ऑपरेटिंग सिस्टम की न्यूलाइन पर सेट है। से भी छोटा है"\n"

a.map(&:join).join $/सभी सरणियों aको स्वयं के एकल-स्ट्रिंग संस्करण में मैप करें (जैसे ['a','b','c']-> 'abc')। उस नए ऐरे को लें और उसे नई सुर्खियों में शामिल करें। प्रभावहीन वापसी।

Comments

o * o छोटा है तो ** 0.5

— edc65

Answer 4

पायथन 3 , 286 बाइट्स

import random as r
i=input()
l=len(i)
a=range(-l,l+1)
g=[(y,x)for y in a for x in a]
p=[(y,x)for y,x in g if abs(x+y*1j)<=l and x|y]
m=i[l//2]
d=[*i.replace(m,"",1).center(len(p))]
r.shuffle(d)
o=""
for c in g:
	o+=m if c==(0,0)else d.pop()if c in p else" "
	if c[1]==l:o+="\n"
print(o)

इसे ऑनलाइन आज़माना एक विकल्प है।

हूप्स, हाल की गतिविधि के कारण इस पर ठोकर खाई, यह ध्यान नहीं दिया कि यह दो साल से अधिक पुराना था जब तक कि मैंने इस पर अच्छा खर्च नहीं किया। खैर, दो जवाब दुख की बात है, तो यह शायद वैसे भी पोस्ट करने के लिए एक अच्छा विचार है। मुझे यकीन है कि इस पर सुधार करने के दर्जनों तरीके हैं - अभी तक ध्यान नहीं दिया है कि इनपुट हमेशा विषम होता है, जिसे जानना उपयोगी होता।

व्याख्या

i=input()बेशक, l=len(i)यह स्ट्रिंग की लंबाई को बचा रहा है, क्योंकि यह काफी बार उपयोग किया जाता है।

a=range(-l,l+1) - एक त्वरित उपकरण, जो एक आयाम के साथ दोनों तरीकों से मूल से दूर उपलब्ध दूरी को लेकर बनाता है।

g=[(y,x)for y in a for x in a] टपल निर्देशांक की एक सूची बनाता है जो पूरे अंतिम ग्रिड को बनाता है।

p=[(y,x)for y,x in g if abs(x+y*1j)<=l and x|y] सूची का एक सबसेट बनाता है जिसमें केवल निर्देशांक होते हैं कि गैर-केंद्र पत्र संभवतः जमीन पर उतर सकते हैं।

m=i[l//2] केंद्र चरित्र स्थापित करता है।

d=[*i.replace(m,"",1).center(len(p))]- केंद्र के चरित्र को बाहर ले जाया गया, हमें दूसरे मलबे के साथ छोड़कर। यहां center()फ़ंक्शन बहुत अच्छा है, क्योंकि यह हमें एक निश्चित संख्या में वर्णों तक लंबी लाइन (डिफ़ॉल्ट रूप से एक स्थान के साथ) को पैड करने की अनुमति देता है। यहाँ, यह है कि अक्षरों की संख्या कितनी है, इस प्रकार हम वितरण की जरूरत को पूरा कर सकते हैं।

r.shuffle(d) स्वाभाविक रूप से फेरबदल ने वितरण को वास्तव में कहा ... वितरित किया गया।

लूप, for c in g: o+=m if c==(0,0)else d.pop()if c in p else" "संभव टाइलों के पूरे वर्ग पर दिखता है, चाहे कुछ भी संभवतः उस पर उतरता है या नहीं, और आवश्यकतानुसार, हमारे आउटपुट स्ट्रिंग में एक चरित्र जोड़ता है o। हमारे मलबे के नमूने से वर्ण पॉप आउट किए जाते हैं ताकि वे केवल एक बार दिखाई दें।

if c[1]==l:o+="\n"- एड्स लाइन भी टूट जाती है। रिटर्न।