तार और संख्या के साथ मज़ा

13

यहाँ आपके लिए एक प्रोग्रामिंग पहेली है:

उदाहरण के लिए, तार और इसी संख्याओं के जोड़े की सूची को देखते हुए, एक [[A,37],[B,27],[C,21],[D,11],[E,10],[F,9],[G,3],[H,2]]अन्य सूची का उत्पादन करें, जिसमें निम्नलिखित तरीके से सिर्फ तार होंगे:

  1. किसी भी स्ट्रिंग की कुल गणना इनपुट डेटा में इसकी संबंधित संख्या के बराबर होनी चाहिए।

  2. किसी भी स्ट्रिंग को अनुक्रम में निकटवर्ती दोहराया नहीं जाना चाहिए, और प्रत्येक स्ट्रिंग को आउटपुट सूची में दिखाई देना चाहिए।

  3. अगले तार का चयन अनियमित रूप से किया जाना चाहिए जब तक कि वे दो नियमों से ऊपर नहीं टूटते। प्रत्येक समाधान में चुने जाने की गैर-शून्य संभावना होनी चाहिए।

  4. यदि कोई संयोजन संभव नहीं है, तो आउटपुट बस होना चाहिए 0।

इनपुट सूची किसी भी क्रम में दी जा सकती है (सॉर्ट या अनसर्टेड), और सूची में तार किसी भी लम्बाई के हो सकते हैं।

उपरोक्त नमूना इनपुट के लिए नमूना आउटपुट 1

[A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,B,A,C,A,C,A,C,A,C,A,C,A,C,A,C,A,C,A,C,A,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,D,C,E,F,E,F,E,F,E,F,E,F,E,F,E,F,E,F,E,F,E,G,H,G,H,G]

इनपुट नमूना 2:

[[A,6],[B,1],[C,1]]

दूसरे इनपुट के लिए आउटपुट:

0

चूंकि नियमों के आधार पर कोई सूची संभव नहीं है।

नमूना इनपुट 3:

[[AC,3],[BD,2]]

मान्य आउटपुट: [AC,BD,AC,BD,AC]

अमान्य आउटपुट: [AC,BD,AC,AC,BD]

यदि आगे स्पष्टीकरण की आवश्यकता है, तो कृपया मुझे टिप्पणियों में बताने में संकोच न करें और मैं तुरंत उसके अनुसार कार्य करूंगा।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए बाइट्स में सबसे छोटा कोड है!

code-golf  string  number  random  combinatorics 
— Stupid_Intern
स्रोत
अच्छी चुनौती! मुझे लगता है कि यह हमारे मानकों से थोड़ा कम है। मैं एक चुनौती पोस्ट करने से पहले बहुत सारे फीडबैक प्राप्त करने के लिए सैंडबॉक्स के उपयोग की अत्यधिक सलाह देता हूं ताकि आपको डाउनवोट या करीबी वोट न मिले! :-) मैं आप से अधिक अच्छी चुनौतियों को देखने के लिए उत्सुक हूं!
— ग्यूसेप
@Giuseppe धन्यवाद मैं उस के माध्यम से जाने की कोशिश करेंगे। अगर मुझे इसमें कोई कमी आती है तो मुझे कोई विवरण जोड़ने की जरूरत है।
— स्तूप_इंटरटेन
1
क्या हम 2 इनपुट ले सकते हैं, सिर्फ स्ट्रिंग्स और सिर्फ नंबर?
— फ्रॉनीफ्रॉग
'यादृच्छिक' वाक्यांश के उपयोग में अस्पष्टता हो सकती है, इनमें से कई समाधान "यादृच्छिक" पुस्तकालयों का उपयोग कर रहे हैं जो वास्तव में केवल छद्म आयामी हैं।
— उज्ज्वल

जवाबों:

6

जेली , 11 बाइट्स

Œṙ'Œ!⁻ƝẠ$ƇX

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

Œṙ'Œ!⁻ƝẠ$ƇX Arguments: z
  '         Flat: Apply link directly to x, ignoring its left and right depth properties
Œṙ            Run-length decode
   Œ!       Permutations of x
         Ƈ  Filter; keep elements of x for which the link returns a truthy result
        $     ≥2-link monadic chain
      Ɲ         Apply link on overlapping pairs (non-wrapping)
     ⁻            x != y
       Ạ        Check if all elements of x have a truthy value (+vacuous truth)
          X Pick a random element of x; return 0 if the list is empty.
— आउटगोल्फ को एरिक करें
स्रोत
अगर Œṙयह '
— सदिश
5

जेली , 17 बाइट्स

Wẋ¥Ɲ€ẎẎŒ!Œɠ’SƊÐḟX

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

— HyperNeutrino
स्रोत
जब मैं कोशिश ["A", 100], ["B", 3]करता हूं कि यह कुछ भी आउटपुट नहीं करता है तो मुझे लगता है कि यह अटक गया है।
— स्तूप_इंटरटेन
1
@newguy 103 वस्तुओं के सभी क्रमपरिवर्तन उत्पन्न करना अपनी गति के लिए प्रसिद्ध नहीं है। संदर्भ के लिए, इसके बाद का परिणाम Œ!9902900716486180407546715254581773349090165822114492483005280555599998766848422828328144147883538492653578588597792929932228228228448444 है।
— आउटगॉल्फ
@newguy यह समाधान है, O(n!)लेकिन यह छोटा है और गति से कोई फर्क नहीं पड़ता। जहाँ यह संख्या 6-8 या इससे अधिक हो, वहां कुछ भी करने की कोशिश न करें: P
— HyperNeutrino
Œṙमदद कर सकता है?
— अरनुलद
1
@dylnan मुझे नहीं लगता कि यह मेरे द्वारा किए गए स्ट्रिंग्स के लिए काम कर रहा है ["AT", 3], ["B", 3]और TBATATBABआउटपुट के रूप में मिला है जो गलत है
— Stupid_Intern
5

अजगर 2 , 114 189 185 174 बाइट्स

from random import*
a=input()
s=u=[]
while a:x,y=a.pop(a.index(next((w for w in a if w[1]>sum(v[1]for v in a+u)/2),choice(a))));s=s+[x];a+=u;u=[[x,y-1]]*(y>1)
print[s,0][y>1]

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

आउच! नियम 3 के साथ बहुत कठिन ... :)। अभी भी O(n!)दृष्टिकोण से बचने की कोशिश कर रहा है , इसलिए यह ब्रह्मांड की गर्मी से मौत से कुछ समय पहले सभी परीक्षण मामलों को संभाल सकता है ...

एल्गोरिथम: मान लें कि स्ट्रिंग की कुल संख्या है t। यदि किसी भी स्ट्रिंग के nसाथ गिनती है 2*n>t+1, तो बाधाओं को संतुष्ट करना संभव नहीं है। इसलिए, यदि किसी भी स्ट्रिंग (पहले चुने गए एक को छोड़कर) के nसाथ गणना की गई है 2*n=t+1, तो हमें अगले स्ट्रिंग को चुनना होगा। अन्यथा, हम यादृच्छिक किसी भी स्ट्रिंग को चुन सकते हैं जो पहले से चुना गया स्ट्रिंग नहीं है।

— चास ब्राउन
स्रोत
1
@ अरनल्ड: पूरी तरह से याद किया! अब तय हो गया।
— चास ब्राउन
4

आर , 148 141 बाइट्स

function(x,y,p=combinatXXpermn(rep(seq(y),y)),q=which(sapply(lapply(p,diff),all)))"if"(n<-sum(q|1),"if"(n-1,x[p[[sample(q,1)]]],x[p[[q]]]),0)

इसे ऑनलाइन आज़माएं! (मैंने इसे कॉपी किया है combinat::permnऔर combinatXXpermnवहां बुलाया है ।)

क्रूर बल O (n!) समाधान।

पैकेज से सभी संभव आदेश उत्पन्न करने के लिए उपयोग करता permnहै combinat। फिर यह देखने के लिए जांचें कि क्या कोई नियमों का पालन करता है, और उनमें से एक को यादृच्छिक रूप से चुनता है।

— एन जी एम
स्रोत
n<-sum(n|1)मुझे विश्वास है कि एक बाइट छोटी है। लेकिन sampleलंबाई-एक इनपुट के साथ क्वर्की यहां बहुत निराशाजनक है।
— ग्यूसेप
इसे थोड़ा सा नीचे गढ़ा, इसे यहाँ आज़माएं - मुझे लिंक को काफी छोटा करने के लिए हेडर से कॉम्बीनाटैक्स्पर्म को निकालना पड़ा ...
— Giuseppe
मेरे पास डेटाफ़्रेम के रूप में बहुत कुछ इसी तरह का इनपुट था। Bruteforce के साथ मुद्दा यह है कि बहुत बड़े हैं इनपुट संभाल नहीं होगा ...
— JayCe
@JayCe इस चुनौती के नियम 3 को देखते हुए एक नॉन-ब्रूट फोर्स एल्गोरिथम भी संभव है?
— एन जी एम
मैं मानता हूँ यह नहीं हो सकता है। नियम 3 के बिना और अधिक दिलचस्प होगा
— जेसी
3

जावास्क्रिप्ट, 112 बाइट्स

इस पर पहले पास, और अधिक गोल्फिंग (उम्मीद है) का पालन करें।

f=([i,...a],o=[])=>a.sort((x,y)=>(y[1]-x[1])*Math.random()-n*.5,n=--i[1],o.push(i[0]))+a?f(n?[...a,i]:a,o):n?0:o

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

— झबरा
स्रोत
1
धन्यवाद, @ अरण्युल, मैं चूक गया था। चास की अगुवाई में केवल आँख बंद करके के बजाय कल्पना की दोहरी जाँच करनी चाहिए। त्वरित रूप से लागू किया गया, बाद में यह देखने के लिए वापस आना होगा कि क्या मैं इसे बेहतर तरीके से गोल्फ कर सकता हूं।
— झबरा
हाँ, 3 नियम esolangs के लिए ठीक है जो आसानी से वैसे भी सभी समाधानों को बल दे सकता है, लेकिन यह अन्य भाषाओं में छोटे एल्गोरिदम को लागू करने के लिए काफी कठिन बनाता है ... BTW: यह अब समय-समय पर मान्य प्रविष्टियों पर 0 लौटाता है ।
— अरनुलद
एक और क्विक फिक्स लागू किया, @Arnauld - अगर वह इसे सॉर्ट नहीं करता है, तो मुझे फिर से डिलीट करना होगा जब तक कि मेरे पास इसे देखने के लिए अधिक समय न हो। नोट: मैंने इसके शब्द पर कल्पना की है कि अगले तार को यादृच्छिक रूप से चुना जाना चाहिए, जिसका अर्थ है कि पहला चयन यादृच्छिक नहीं होना चाहिए।
— शैगी
1
@ शैगी - मैं सहमत हूँ, आपको कभी भी आँख बंद करके कुछ भी नहीं करना चाहिए! :)
— चास ब्राउन
3

जे, 60 53 बाइट्स

-7 FrownyFrog के लिए धन्यवाद

(?@#{])@(#~*/@(2~:/\])"1)@(]i.@!@#@;A.;) ::0(#~>)/&.>

मूल

(?@#{])@(#~2&([:*/~:/\)"1)@(A.~i.@!@#)@;@:(([#~>@])/&.>) ::0

ungolfed

(?@# { ])@(#~ 2&([: */ ~:/\)"1)@(A.~ i.@!@#)@;@:(([ #~ >@])/&.>) ::0

सुधार के स्वागत के सुझाव।

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

— जोनाह
स्रोत
— FrownyFrog
भयानक tyvm @FrownyFrog, मैं बाद में पोस्ट अपडेट करूंगा
— जोनाह
ओह, [:*/2~:/\|:दो छोटे हैं
— FrownyFrog
2

चारकोल , 38 बाइट्स

ＷΦθ§κ¹«≔‽Φ∨Φι›⊗§κ¹ΣＥι§μ¹ι¬⁼κυυ§υ⁰⊞υ⊖⊟υ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＷΦθ§κ¹«

कम से कम एक गैर-शून्य गिनती होने पर दोहराएं।

Φι›⊗§κ¹ΣＥι§μ¹

ऐसी कोई भी गणना ज्ञात करें, जो शेष आधे से अधिक बनाये।

∨...ι

यदि कोई नहीं था, तो पहले से फ़िल्टर किए गए नॉन-जीरो काउंट को ही लें।

Φ...¬⁼κυ

पिछली बार आउटपुट वाले स्ट्रिंग को फ़िल्टर करें।

≔‽∨...υ

उपरोक्त दो सूचियों के पहले गैर-खाली से अंतिम आउटपुट स्ट्रिंग तक एक यादृच्छिक तत्व असाइन करें। ध्यान दें कि यदि एक असंभव संयोजन दर्ज किया गया है, तो कार्यक्रम इस बिंदु पर दुर्घटनाग्रस्त हो जाएगा।

§υ⁰

स्ट्रिंग प्रिंट करें।

⊞υ⊖⊟υ

इसकी गिनती में कमी।

— नील
स्रोत
यह अमान्य आउटपुट उत्पन्न करता है, जैसे कि आपके उदाहरण ["h4x0r", 1337]में एक स्ट्रिंग के रूप में शामिल किया गया है।
— एन जी एम
@ngm मैंने कोड को फिर से व्यवस्थित किया है और यदि आप ऐसा करते हैं तो यह अब क्रैश हो जाता है ... उचित सत्यापन दुर्भाग्य से अधिक बाइट खर्च करने वाला है।
— नील
2

रूबी , 85 बाइट्स

जानवर बल दृष्टिकोण (विचार के लिए धन्यवाद जोनाह)।

->l{l.flat_map{|a,b|[a]*b}.permutation.select{|p|r=0;p.all?{|a|a!=r&&r=a}}.sample||0}

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

रूबी , 108 100 96 बाइट्स

पहले, बोगोसोर्ट दृष्टिकोण

->l{w=[];l.map{|a,b|w+=[a]*b;b}.max*2>w.size+1?0:(w.shuffle!until(r='';w.all?{|a|a!=r&&r=a});w)}

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

— जीबी
स्रोत
यहाँ 93 के लिए एक है: इसे ऑनलाइन आज़माएं!
— योना
2

जंग 633 बाइट्स

दूसरों की तुलना में यह थोड़ा अलग है कि यह एक भौतिक प्रणाली का अनुकरण करके तार को पुनर्व्यवस्थित करने के विचार के साथ शुरू हुआ। प्रत्येक स्ट्रिंग को पहले उपयुक्त संख्या में दोहराया जाता है। फिर प्रत्येक व्यक्तिगत स्ट्रिंग को एक अंतरिक्ष में एक कण के रूप में माना जाता है। एक ही स्ट्रिंग मान वाले दो कण एक दूसरे को "रीपेल" करते हैं, जबकि विभिन्न मूल्यों वाले दो कण एक दूसरे को आकर्षित करते हैं। उदाहरण के लिए यदि हम AAAAAAABBBBCC से शुरू करते हैं, तो अस एक दूसरे को निरस्त कर देंगे, एक दूसरे से दूर जा रहे हैं, जिससे Bs उन्हें अंदर जाने की अनुमति देता है। समय के साथ यह कणों के एक अच्छे मिश्रण तक पहुँच जाता है। 'पार्टिकल मूवमेंट' के प्रत्येक पुनरावृत्ति के बाद, प्रोग्राम जांचता है कि कोई समान-कण आसन्न नहीं हैं, फिर सिस्टम की स्थिति को रोकता है और प्रिंट करता है, जो कि क्रम में तारों की सूची है, जैसा कि वे 1 आयामी स्थान में दिखाई देते हैं।

अब, जब यह वास्तव में उस भौतिक प्रणाली को लागू करने की बात आती है, तो यह प्रत्येक कण की स्थिति और वेग को संख्याओं के रूप में संग्रहीत करने के लिए पुराने फ़ैशन पीसी डेमो / गेम तकनीक का उपयोग करने के रूप में शुरू हुआ, फिर पुनरावृत्तियों के माध्यम से स्थिति और वेग को अपडेट करें। प्रत्येक पुनरावृत्ति पर, हम वेग को स्थिति (आंदोलन) में जोड़ रहे हैं, और त्वरण को वेग में जोड़ रहे हैं (गति की गति में परिवर्तन), और त्वरण की गणना (कण पर बल का पता लगाना)। सरल बनाने के लिए, सिस्टम अन्य सभी कणों के आधार पर प्रत्येक कण पर बल की गणना नहीं करता है - यह केवल आसन्न कणों की तुरंत जांच करता है। एक 'भिगोना' प्रभाव भी था ताकि कण बहुत अधिक तेजी से न बढ़ें और अनंत तक उड़ जाएं (प्रत्येक उदाहरण के लिए x प्रतिशत में प्रत्येक चरण में वेग कम हो जाता है)।

गोल्फिंग की प्रक्रिया के माध्यम से, हालांकि, इस पूरी चीज को काट दिया गया और काफी सरल किया गया। अब, दो एक जैसे कणों को एक-दूसरे को खदेड़ने के बजाय, वे बस 'टेलीपोर्ट' करते हैं। सिस्टम में ठहराव को रोकने के लिए अलग-अलग कण बस 'स्कूटर' को एक मूत देते हैं। उदाहरण के लिए यदि A A के बगल में है तो वह टेलीपोर्ट करेगा। यदि A, B के बगल में है तो यह केवल थोड़ा बदलाव होगा। फिर यह जांचता है कि क्या शर्तें पूरी होती हैं (आसन्न कणों की तरह नहीं) और क्रम में तारों को प्रिंट करता है, 1-डी अंतरिक्ष में उनकी स्थिति के आधार पर। यह अनुकरण की तुलना में लगभग एक छँटाई एल्गोरिथ्म की तरह है - फिर फिर, कोई 'द्रव्यमान' के आधार पर सिम्युलेटेड 'बहती' के रूप में छँटाई एल्गोरिदम देख सकता है। मैंने खुद को पीछे कर लिया।

वैसे भी, यह मेरे पहले रस्ट प्रोग्रामों में से एक है इसलिए मैंने कई घंटों के गोल्फिंग के बाद हार मान ली, हालांकि अभी भी मौके हो सकते हैं। मेरे लिए पार्सिंग बिट मुश्किल है। यह मानक इनपुट से इनपुट स्ट्रिंग को पढ़ता है। यदि वांछित है, तो इसे "let mut s =" [[A, 3], [B, 2]] "से बदला जा सकता है। लेकिन अभी मैं 'echo [[A, 3], [B, 2]] करता हूं। कार्गो रन 'कमांड लाइन पर।

रुकने की गणना एक समस्या है। कैसे पता लगाया जाए कि सिस्टम की वैध स्थिति कभी नहीं पहुंच पाएगी? पहली योजना यह पता लगाने की थी कि क्या 'वर्तमान' राज्य कभी एक पुरानी स्थिति को दोहराता है, उदाहरण के लिए यदि एसीसीसी सीएसीसी में बदल जाता है लेकिन फिर एसीसीसी में हम जानते हैं कि कार्यक्रम कभी समाप्त नहीं होगा, क्योंकि यह केवल छद्म यादृच्छिक है। यह तब छोड़ देना चाहिए और यदि ऐसा हुआ हो तो 0 प्रिंट करें। हालाँकि यह बहुत बड़ी मात्रा में रस्ट कोड की तरह लग रहा था, इसलिए मैंने सिर्फ यह तय किया कि अगर यह अधिक संख्या में पुनरावृत्तियों से गुज़रता है, तो शायद यह स्थिर हो जाएगा और कभी भी स्थिर अवस्था में नहीं पहुंचेगा, इसलिए यह 0 पर रुक जाता है और रुक जाता है। कितने? कणों की संख्या चुकता।

कोड:

extern crate regex;
struct P {s:String,x:i32,v:i32}
fn main() {
    let (mut i,mut j,mut p,mut s)=(0,0,Vec::new(),String::new());
    std::io::stdin().read_line(&mut s);
    for c in regex::Regex::new(r"([A-Z]+),(\d+)").unwrap().captures_iter(&s) {
        for _j in 0..c[2].parse().unwrap() {p.push(P{s:c[1].to_string(),x:i,v:0});i+=1;}
    }
    let l=p.len(); while i>1 {
        j+=1;i=1;p.sort_by_key(|k| k.x);
        for m in 0..l {
            let n=(m+1)%l;
            if p[m].s==p[n].s {p[m].v=p[m].x;if n!=0 {i=2}} else {p[m].v=1}
            p[m].x=(p[m].x+p[m].v)%l as i32;
        }
        if j>l*l{p.truncate(1);p[0].s="0".to_string();i=1}
    }
    for k in &p{print!("{}",k.s)};println!();
}
— चमकाओ
स्रोत
l2regex
इसने मेरे द्वारा दिए गए उदाहरणों को पारित कर दिया, हालाँकि मैंने इसे फ़ज़ नहीं किया। मैंने इसे TIO में काम करने के लिए संशोधित किया है, आपको 'let s = [("A", 3), ("B", 2), ("ZZ", 4)] को संशोधित करने की आवश्यकता है; लाइन, bit.ly/2LubonO
— ब्राइट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.