[Br] eaking कोड गोल्फ [बा] डी

Question

निम्नलिखित स्ट्रिंग पर विचार करें:

Tin Snips

इस स्ट्रिंग में आवर्त सारणी पर कई परमाणु चिन्ह होते हैं । हम उनमें से कई की पहचान करने के लिए इस स्ट्रिंग को फिर से लिख सकते हैं:

[Ti][N] [Sn][I][P][S]

बेशक, हम इसे इस तरह भी लिख सकते हैं:

T[In] [S][Ni][P][S]

इनपुट को फिर से लिखने के नियम इस प्रकार हैं:

1. परमाणु प्रतीकों के मिलान के मामले में इनपुट का मामला मायने नहीं रखता है।
2. यदि किसी तत्व का उपयोग परमाणु प्रतीक में किया जाता है, तो इसका मामला बदलना चाहिए, इसलिए प्रतीक सही है। Ex: hबन जाएगा [H]।
3. सभी तत्व प्रतीक ASCII वर्ग कोष्ठक में संलग्न हैं, [और ]।
4. व्हॉट्सएप संरक्षित है: Big ego"g" और "e" को संयोजित नहीं कर सकता [Ge]।
5. सभी इनपुट वर्णों को परमाणु प्रतीक में संयोजित करने की आवश्यकता नहीं है: यदि किसी इनपुट चरित्र को प्रतीक में नहीं रखा गया है, तो इसे as-is (मामला मायने नहीं रखता) के माध्यम से पारित किया जाता है।
6. यदि कोई प्रतीक बनाया जा सकता है, तो उसे बनाया जाना चाहिए। दूसरे शब्दों में, इसे Tinउपरोक्त उदाहरण में आउटपुट करने की अनुमति नहीं है क्योंकि उस शब्द में कम से कम एक प्रतीक बनाना संभव है। किसी चरित्र को अप्रयुक्त के माध्यम से पारित किया जा सकता है जब केवल एक परमाणु प्रतीक का निर्माण करने के लिए इस्तेमाल नहीं किया जा सकता है।
7. इस चुनौती के प्रयोजनों के लिए, हाइड्रोजन (1) से ओगेनेसन (118) तक सभी तत्व मान्य हैं। कोई उच्च तत्व मान्य नहीं हैं।
8. कुछ उच्च तत्वों में अस्पष्ट नाम और प्रतीक हैं: इस चुनौती के प्रयोजनों के लिए, विकिपीडिया पर संस्करण का उपयोग किया जाएगा। सुविधा के लिए, स्वीकार्य परमाणु प्रतीक यहां हैं: H, He, Li, Be, B, C, N, O, F, Ne, Na, Mg, Al, Si, P, S, Cl, Ar, K, Ca, Sc, Ti, V, Cr, Mn, Fe, Co, Ni, Cu, Zn, Ga, Ge, Ge, As, Se, Br, Kr, Rb, Sr, Y, Zr, Nb, Mo, Tc, Ru, Rh, Pd, Ag, Cd, In, Sn, Sb, Te, I, Xe, Cs, Ba, La, Ce, Pr, Nd, Pm, Sm, Eu, Gd, Tb, Dy, Ho, Er, Tm, Yb, लू, Hf, Ta, W, Re, Os, Ir, Pt, Au, Hg, Tl, Pb, Bi, Po, At, Rn, Fr, Ra, Ac, Th, Pa, U, Np, Pu, Am, Cm, Bk, Cf, Es, Fm, Md, No, Lr, Rf, Db, Sg, Bh, Hs, Mt, Ds, Rg, Cn, Nh, Fl, Mc, Lv, Ts, Og।

एक प्रोग्राम या फ़ंक्शन लिखें जो एकल प्रदान किए गए इनपुट से सभी संभावित आउटपुट उत्पन्न करता है। इनपुट और आउटपुट दोनों आपके चयन के किसी भी रूप में हो सकते हैं। यह एक स्ट्रिंग, वर्णों की सरणी या कुछ अन्य डेटा संरचना हो सकती है: जो कुछ भी सुविधाजनक और स्पष्ट रूप से इनपुट और आउटपुट दोनों का प्रतिनिधित्व करता है। इनपुट और आउटपुट दोनों आपके कोड से बाहर / पास हो सकते हैं, हालांकि आप चुनते हैं: मानक इन / आउट, फ़ंक्शन तर्क / रिटर्न, या कुछ और।

• इनपुट सकारात्मक लंबाई का एक स्ट्रिंग (पिछले पैराग्राफ देखें) हो सकता है जिसमें केवल मनमानी मामले के ASCII वर्ण और स्थान ( 0x20) वर्ण हो।
• आपके कोड को उन सभी आउटपुट स्ट्रिंग्स को उत्पन्न करना होगा जो ऊपर दिए गए इनपुट नियमों का उपयोग करके बनाए जा सकते हैं।
• आउटपुट का क्रम कार्यान्वयन-परिभाषित है। केवल आवश्यकता यह है कि सभी आउटपुट स्ट्रिंग्स मौजूद हैं।
• यदि एक वैध इनपुट स्ट्रिंग के साथ प्रस्तुत किया जाता है जिसमें कोई परमाणु प्रतीक नहीं होते हैं, तो बस इनपुट स्ट्रिंग को आउटपुट करें।
• यदि इनपुट स्ट्रिंग के साथ प्रस्तुत किया गया है जो ऊपर दिए गए नियमों के अनुसार मान्य नहीं है (शून्य, शून्य वर्ण, जिसमें अवैध वर्ण हैं, आदि) आपका प्रोग्राम कुछ भी कर सकता है (क्रैश, रिक्त आउटपुट, आदि)
• आवर्त सारणी के मिलान के लिए परमाणु प्रतीकों के अलावा आउटपुट केस-असंवेदनशील है।
• मानक खामियों की अनुमति नहीं है।

परीक्षण के मामलों:

Tin Snips
[Ti][N] [Sn][I][P][S]
[Ti][N] [S][Ni][P][S]
[Ti][N] [S][N][I][P][S]
T[In] [Sn][I][P][S]
T[In] [S][Ni][P][S]
T[In] [S][N][I][P][S]
T[I][N] ...

Quack
Q[U][Ac][K]
Q[U]a[C][K]

hehe
[H]e[H]e
[H]e[He]
[He][H]e
[He][He]

Stack Exchange
[S][Ta][C][K] Ex[C][H]a[N][Ge]
[S]t[Ac][K] Ex[C][H]a[N][Ge]

यह कोड गोल्फ है, तो मुझे अपना सबसे छोटा कोड देखने दो!

Comments

प्रति @ रस्सर टिप्पणी टिन T[I][N]नहीं होगी [T][I][N]क्योंकि टी एक तत्व नहीं है। मेरा सवाल (और संभवतः रस्सर का) है: क्या हमें केवल १ ही देना है। केवल वे ही आउटपुट हैं जहाँ अधिकतम तत्व संख्याएँ घटती हैं? 2. अपव्यय की केवल न्यूनतम राशि? (हाइड्रोजन्स के साथ HeHe यह एक नहीं का जवाब इंगित करता है) 3. सभी आउटपुट जहां मैच पूरी तरह से समाप्त हो जाते हैं? (इस मामले T[I][N]में और साथ ही T[In]मान्य होगा।) मुझे लगता है कि सही व्याख्या है 3.

— लेवल रिवर सेंट

मुझे लगता है कि यह एक डुबकी है

— डिजिटल ट्रॉमा

तो क्वैक के लिए 2 संभावनाएं हैं: Q[U][Ac][K]और Q[U]a[C][K]। सही?

— रूटट्वो

सभी मामलों का सत्यापन किया गया।

— कैलकुलेटरफाइनल

@ Challenger5 "आपके कोड में सभी इनपुट स्ट्रिंग्स उत्पन्न होने चाहिए जो कि ऊपर दिए गए इनपुट नियमों का उपयोग करके बनाए जा सकते हैं"

— जोनाथन एलन

Answer 1

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

Pypi पर अधिक पूर्ण पुस्तकालय मिला: mendeleev

from mendeleev import*
Z={element(i).symbol for i in range(1,119)}
L,R='[]'
def f(h,r=''):t=h.title();return((Z&{t[0]}and f(h[1:],r+L+t[0]+R)or[])+(Z>{(t+L)[:2]}and f(h[2:],r+L+t[:2]+R)or[])+(not{(r[-1:]+t[0]).title(),t[0]}&Z and f(h[1:],r+h[0])or[]))if h else[r]

पुराना उत्तर:

from elements import*
Z={e.symbol for e in ELEMENTS}|{*'Cn Ds Fl Lv Mc Nh Og Rg Ts'.split()}
L,R='[]'
def f(h,r=''):t=h.title();return((Z&{t[0]}and f(h[1:],r+L+t[0]+R)or[])+(Z>{(t+L)[:2]}and f(h[2:],r+L+t[:2]+R)or[])+(not{(r[-1:]+t[0]).title(),t[0]}&Z and f(h[1:],r+h[0])or[]))if h else[r]

एक पुस्तकालय का उपयोग करता है elements.pyHttp://www.lfd.uci.edu/~gohlke/code/elements.py.html से । यह तत्व 110 से 118 तक गायब है, लेकिन यह मेरे द्वारा खोजे जा सकने वाले पुस्तकालय में सबसे अधिक था। लापता तत्वों को जोड़ने के लिए 40 बाइट का खर्च।

जब एक चरित्र को एक तत्व प्रतीक के भाग के बिना पारित किया जा सकता है, तो सबसे मुश्किल हिस्सा तर्क था।

Comments

उह रुको, mendeleevएक उपयोगकर्ता नहीं था , पुस्तकालय नहीं था ?

— मैथ्यू रो

Answer 2

जेली ,  192  191 बाइट्स

-1 Ɗ(एक के बाद से विकसित त्वरित) के उपयोग से

“¦UV2ḤF2ı½ṅḶḊ⁼5JI5MẇvẋẊẊ¬Ḥḳ'ƈ<ḷėƤ7*⁾ṾxMæS⁺`?^Ƭb¦ɗDß⁼pþɲOṃ⁽2Ė>,Ḣ(ḞŒƊOGƤ×⁺ṇṂ®ȤT0y°^Ẇ⁺:Þ]ṢṬ¶ịṪḂƇ ñAƬCṫ$wÆĿĖỴỴƇẓƊqḌ@;ẏ`ṃFƥḣ⁽²»ḟ⁶s2;“¤²R.ȯ7ŒL£ɦ»Œt
Œte¢
ŒṖµL€=1oÇ€ṂµÐfµṡ2;€ÇÐfÇ€€S€¬SµÐḟ⁾[]jŒtƊ¹Ç?€€

इसे ऑनलाइन आज़माएं!- 60 के दशक की सीमा के भीतर पूरा होने के लिए "स्टैक एक्सचेंज" परीक्षण मामले के लिए बहुत अक्षम (इसे ऑफ़लाइन चलाने से 2 महीने के भीतर सही परिणाम मिलता है)।

कैसे?

सभी 118 तत्व प्रतीकों वाली सूची बनाने के लिए कोड की पहली पंक्ति एक निलादिक लिंक है। ऐसा करने के लिए यह दो सूचियों को सम्‍मिलित करता है, पहली सभी लंबाई 2 वर्णों की सूची (यानी तार) दूसरी वर्ण की सूची और शीर्षक परिणाम मामलों की सूची। दो सूचियाँ खुद ज्यादातर जेली के शब्दकोष में शब्दों को देखकर बनाई गई हैं, ताकि एकल तार लगाए जा सकें।

इनमें से पहला कंप्रेशन है:

“¦UV2ḤF2ı½ṅḶḊ⁼5JI5MẇvẋẊẊ¬Ḥḳ'ƈ<ḷėƤ7*⁾ṾxMæS⁺`?^Ƭb¦ɗDß⁼pþɲOṃ⁽2Ė>,Ḣ(ḞŒƊOGƤ×⁺ṇṂ®ȤT0y°^Ẇ⁺:Þ]ṢṬ¶ịṪḂƇ ñAƬCṫ$wÆĿĖỴỴƇẓƊqḌ@;ẏ`ṃFƥḣ⁽²»

कौन सी पैदावार

" biznagas sepmag ratbag catchflies paracmes mdse bharal ramcat monopteros irrepressibilities lunarnauts geniculate hopbinds rutabaga potlache broghs bergamas crossbirth purblind xebecs nonhardy classism fleurets moneybag scarce corf Mg Sr Zr CD HG CF FM Lr SG TM Gd Bk Fr Rh Fe Sn lv cndbmnnbkrmtpdnp"

जहां सभी लेकिन अंतिम प्रविष्टि (रिक्त स्थान से विभाजित) जेली के शब्दकोश में प्रविष्टियां हैं। रिक्त स्थान को फ़िल्टर किया जाता है ḟ⁶, और फिर परिणाम को दो भागों में विभाजित किया जाता है:

["bi","zn","ag","as","se","pm","ag","ra","tb","ag","ca","tc","hf","li","es","pa","ra","cm","es","md","se","bh","ar","al","ra","mc","at","mo","no","pt","er","os","ir","re","pr","es","si","bi","li","ti","es","lu","na","rn","au","ts","ge","ni","cu","la","te","ho","pb","in","ds","ru","ta","ba","ga","po","tl","ac","he","br","og","hs","be","rg","am","as","cr","os","sb","ir","th","pu","rb","li","nd","xe","be","cs","no","nh","ar","dy","cl","as","si","sm","fl","eu","re","ts","mo","ne","yb","ag","sc","ar","ce","co","rf","Mg","Sr","Zr","CD","HG","CF","FM","Lr","SG","TM","Gd","Bk","Fr","Rh","Fe","Sn","lv","cn","db","mn","nb","kr","mt","pd","np"]

द्वितीय,

“¤²R.ȯ7ŒL£ɦ»

शब्द "फिंच", "पब", "स्काई", और "स्वर" (बिना रिक्त स्थान के) के संयोजन से बनता है, और इस तरह के पात्रों की एक सूची है:

['f','i','n','c','h','p','u','b','s','k','y','v','o','w']

दो सूचियों के साथ सहमति व्यक्त की जाती है ;और प्रत्येक प्रविष्टि शीर्षक-आवरण का उपयोग करके Œt, उपज होती है:

["Bi","Zn","Ag","As","Se","Pm","Ag","Ra","Tb","Ag","Ca","Tc","Hf","Li","Es","Pa","Ra","Cm","Es","Md","Se","Bh","Ar","Al","Ra","Mc","At","Mo","No","Pt","Er","Os","Ir","Re","Pr","Es","Si","Bi","Li","Ti","Es","Lu","Na","Rn","Au","Ts","Ge","Ni","Cu","La","Te","Ho","Pb","In","Ds","Ru","Ta","Ba","Ga","Po","Tl","Ac","He","Br","Og","Hs","Be","Rg","Am","As","Cr","Os","Sb","Ir","Th","Pu","Rb","Li","Nd","Xe","Be","Cs","No","Nh","Ar","Dy","Cl","As","Si","Sm","Fl","Eu","Re","Ts","Mo","Ne","Yb","Ag","Sc","Ar","Ce","Co","Rf","Mg","Sr","Zr","Cd","Hg","Cf","Fm","Lr","Sg","Tm","Gd","Bk","Fr","Rh","Fe","Sn","Lv","Cn","Db","Mn","Nb","Kr","Mt","Pd","Np","F","I","N","C","H","P","U","B","S","K","Y","V","O","W"]

आवश्यक के रूप में सभी 118 तत्व प्रतीकों वाली एक सूची (इसमें डुप्लिकेट हैं, लेकिन यह ठीक है)।

कोड की दूसरी पंक्ति एक मोनैडिक लिंक (एक इनपुट लेने के लिए डिज़ाइन किया गया एक सहायक फ़ंक्शन) है जो 1 रिटर्न देता है यदि इनपुट, शीर्षक-आवरण ऊपर बनाई गई सूची में मौजूद है और 0 अन्यथा।

कोड की तीसरी पंक्ति मुख्य लिंक है, एक मोनोडिक फ़ंक्शन जो एक स्ट्रिंग लेता है और आवश्यक के रूप में वर्णों की सूची (यानी तार) देता है:

ŒṖµL€=1oÇ€ṂµÐfµṡ2;€ÇÐfÇ€€S€¬SµÐḟ⁾[]jŒtƊ¹Ç?€€ - Main link: s
ŒṖ                                           - all partitions of s
  µ        µÐf                               - filter keep:
   L€=1                                      -     length €ach equals (vectorises) 1
       o                                     -     or
        ǀ                                   -     last link as a monad (is an element when title-cased)
          Ṃ                                  -     minimum 
                                             - (i.e. all partitions that are all single characters OR are strings that when title-cased are elements)
              µ              µÐḟ             - filter discard:
               ṡ2                            -     slices of length 2
                 ;€                          -     concatenate €ach
                    Ðf                       -     filter keep:
                   Ç                         -         last link as a monad (is an element when title-cased)
                      Ç€€                    -     last link as a monad for €ach for €ach
                         S€                  -     sum €ach
                           ¬                 -     logical not
                            S                -     sum
                                             - (i.e. discard any partitions that contain a run of two that joined together and title-cased ARE an element but separately NEITHER are)
                                         ?€€ - if then else for €ach (partition) for €ach (part):
                                        Ç    -     IF: last link as a monad (is an element when title-cased)
                                             -   THEN:
                                      Ɗ      -         last three links as a monad:
                                ⁾[]                      "[]"
                                   j         -           joined by:
                                    Œt       -           title case the part
                                             -   ELSE:
                                       ¹     -         the part itsef (¹ is the identity atom)

Answer 3

सी ++ 11, 944 928 बाइट्स

यहाँ वास्तव में भयानक कोड का एक टुकड़ा है, लेकिन यह काम करना चाहिए। शायद अभी भी बहुत कम किया जा सकता है।

#import<iostream>
#import<set>
using namespace std;int r,i;set<string>O;S(string&s){s[0]-=s[0]>90?32:0;if(s[1])s[1]+=s[1]<91?32:0;char*l="HHeLiBeBCNOFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnNhFlMcLvTsOg";for(r=0;*l++;)if(*l>90){if(*(l++-1)==s[0]&&*(l-1)==s[1])r=1;}else if(*(l-1)==s[0]&&!s[1])r=1;}P(set<string>*V,string s,string o,int b,int l=0,int m=0){if(!s[b])O.insert(o);else if(l)P(V,s,o,b+1);else if(V[b].size()==0)P(V,s,o+s[b],b+1);else for(auto t:V[b]){P(V,s,o+"["+t+"]",b+1,t.length()-1);if(t.length()>1&&V[b].size()==1&&V[b+1].size()>0&&!m)P(V,s,o+s[b],b+1,0,1);}}F(string s){set<string>V[s.length()];for(i=0;s[i++];){string t="";t+=s[i-1];S(t);if(r)V[i-1].insert(t);t+=s[i];S(t);if(r&&s[i])V[i-1].insert(t);}P(V,s,"",0);for(auto o:O)cout<<o<<"\n";O.clear();}

के साथ बुलाना:

int main()
{
    F("Tin Snips");cout << "\n";
    F("Quack");cout << "\n";
    F("hehe");cout << "\n";
    F("Stack Exchange");
}