फिच टुगेदर विथ अ पालिंड्रोम फ्रॉम पालिंड्रोमिक सबस्ट्रिंग्स

Question

एक स्ट्रिंग को देखते हुए l, सभी मुरजबंध संबंधी सबस्ट्रिंग को खोजने pकी l(डुप्लिकेट और एकल वर्ण तार सहित)। इसके बाद, सभी उप-स्ट्रिंग्स pको एक वैध तालमेल में पुनर्व्यवस्थित करें (कई सही उत्तर हो सकते हैं)। यदि pकिसी एकल तालमेल में पुनर्व्यवस्थित करना संभव नहीं है , तो आपके कार्यक्रम में अपरिभाषित व्यवहार (त्रुटि, स्टैक-ओवरफ़्लो, बाहर निकलना, लटकना / जॉन ड्वोरक, आदि की असामयिक हत्या हो सकती है ...)

---

उदाहरण

वैध परीक्षण मामले

l = anaa
p = ['a', 'n', 'a', 'a', 'aa', 'ana']
result = anaaaaana or aanaaanaa or aaananaaa

l = 1213235
p = ['1', '2', '1', '3', '2', '3', '5', '121', '323']
result = 1213235323121

l = racecar
p = ['r', 'a', 'c', 'e', 'c', 'a', 'r', 'cec', 'aceca', 'racecar']
result = racecarcecaacecracecar (there are others)

l = 11233
p = ['1', '11', '1', '2', '3', '33', '3']
result = 113323311 or 331121133

l = abbccdd
p = ['a', 'b', 'bb', 'b', 'c', 'cc', 'c', 'd', 'dd', 'd']
result = bbccddaddccbb or ccbbddaddbbcc or (etc...)

l = a
p = ['a']
result = a

अमान्य परीक्षण मामले (संभव नहीं)

l = 123456789
p = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
result = <not possible, behavior undefined>

l = hjjkl
p = ['h', 'j', 'jj', 'j', 'k', 'l']
result = <not possible, behavior undefined>

l = xjmjj
p = ['x', 'j', 'jmj', 'm', 'j', 'jj', 'j']
result = <not possible, behavior undefined>

---

नियम

• यदि इनपुट शब्द अपने आप में एक palindrome है, तो यह हमेशा इनपुट के रूप में मान्य होगा।
• केवल एक विकल्प दिया जाना चाहिए, जिसे आप चुनते हैं वह तब तक मनमाना है जब तक यह मान्य है।
• यदि इनपुट में कोई व्यवहार्य आउटपुट नहीं है, तो आपके कोड में अपरिभाषित व्यवहार हो सकता है।
• इनपुट में केवल ASCII-Printable अक्षर होंगे 0x20-0x7E।
• यह कोड-गोल्फ है , सबसे कम बाइट-काउंट विजेता है।

Comments

के लिए पहला प्रस्तावित परिणाम "abbccdd"गलत है: अंतिम दो अक्षर होने चाहिए "bb", नहीं "dd"।

— 15:13 पर घातक

क्या हम एक स्ट्रिंग के बजाय, सब्सट्रिंग्स की एक सरणी लौटा सकते हैं?

— झबरा

क्या मैं इनपुट के रूप में वर्णों की सूची ले सकता हूं?

— alephalpha

स्वीकार्य व्यवहार होने से, क्या आपका मतलब उस व्यक्ति को फांसी देना है जिसने इसे इनपुट दिया है?

— जॉन ड्वोरक

@ जॉनडेवोरक ने स्पष्ट किया।

— मैजिक ऑक्टोपस Urn

Answer 1

ब्रेकीलॉग , 10 बाइट्स

{s.↔}ᶠpc.↔

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

false.यदि संभव न हो तो असफल (यानी प्रिंट )।

व्याख्या

{   }ᶠ         Find all…
 s.              …substrings of the input…
  .↔             …which are their own reverse
      p        Take a permutation of this list of palindromes
       c.      The output is the concatenation of this permutation
        .↔     The output is its own reverse

Answer 2

नारियल , 140 बाइट्स

s->p(map(''.join,permutations(p(v for k in n(s)for v in n(k[::-1])))))[0]
from itertools import*
n=scan$((+))
p=list..filter$(x->x==x[::-1])

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

Answer 3

जावास्क्रिप्ट (ईएस 6), 193 बाइट्स

"देखो मा, कोई परमीशन बिल्ट-इन नहीं!" (तो हां ... यह लंबा है ...)

कोई समाधान नहीं होने पर एक खाली सरणी देता है।

f=(s,a=[].concat(...[...s].map((_,i,a)=>a.map((_,j)=>s.slice(i,j+1)))).filter(P=s=>[...s].reverse().join``==s&&s),m=S=[])=>S=a.map((_,i)=>f(s,b=[...a],[...m,b.splice(i,1)]))>''?S:P(m.join``)||S

डेमो

f=(s,a=[].concat(...[...s].map((_,i,a)=>a.map((_,j)=>s.slice(i,j+1)))).filter(P=s=>[...s].reverse().join``==s&&s),m=S=[])=>S=a.map((_,i)=>f(s,b=[...a],[...m,b.splice(i,1)]))>''?S:P(m.join``)||S

console.log(f('anaa'))
console.log(f('1213235'))
console.log(f('hjjkl'))
console.log(f('a'))

कैसे?

कोड को छोटे भागों में विभाजित करते हैं।

हम पी () को परिभाषित करते हैं , एक फ़ंक्शन जो एस लौटाता है यदि एस एक palindrome है, या अन्यथा गलत है।

P = s => [...s].reverse().join`` == s && s

हम इनपुट स्ट्रिंग एस के सभी सबस्ट्रिंग की गणना करते हैं । पी () का उपयोग करते हुए , हम गैर-खाली पलिंडोम को अलग करते हैं और उन्हें सरणी ए में संग्रहीत करते हैं ।

a = [].concat(...[...s].map((_, i, a) => a.map((_, j) => s.slice(i, j + 1)))).filter(P)

मुख्य पुनरावर्ती फ़ंक्शन f () इनपुट के रूप में लेता है और इसके सभी क्रमपरिवर्तन की गणना करता है। यह एस को अपडेट करता है जब भी क्रमपरिवर्तन एक पैलिंड्रोम होता है (एक बार शामिल हो जाता है), और अंततः एस का अंतिम मूल्य लौटाता है ।

f = (                        // given:
  a,                         //   a[] = input array
  m = S = []                 //   m[] = current permutation of a[]
) =>                         //   and S initialized to []
  S = a.map((_, i) =>        // for each element at position i in a[]:
    f(                       //   do a recursive call with:
      b = [...a],            //     b[] = copy of a[] without the i-th element
      [...m, b.splice(i, 1)] //     the element extracted from a[] added to m[]
    )                        //   end of recursive call
  ) > '' ?                   // if a[] was not empty:
    S                        //   let S unchanged
  :                          // else:
    P(m.join``) || S         //   update S to m.join('') if it's a palindrome

Answer 4

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

ŒḂÐf
ẆÇŒ!F€ÇḢ

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

0अमान्य मामले में प्रिंट ।

Answer 5

05AB1E , 13 12 बाइट्स

ŒʒÂQ}œJʒÂQ}¤

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

मैजिक ऑक्टोपस यूरन और एनिग्मा को -1 बाइट।

Comments

Jस्वचालित रूप से फैक्ट करता है, इसलिए आपको €Jसिर्फ ज़रूरत नहीं है J; इसके अलावा, आप सभी में से किसी एक को पलिंड्रोम वापस करने वाले हैं। इसे ऑनलाइन आज़माएं! उसी बाइट-काउंट के लिए मान्य है।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn फिक्स्ड, धन्यवाद!

— कालडो

Ùćहो सकता है ¤(या अन्य विकल्पों में से एक नंबर)

— Emigna

@Emigna को यकीन नहीं है कि मुझे Ùइसकी आवश्यकता क्यों नहीं थी।

— मैजिक ऑक्टोपस Urn

एनिग्मा माय बैड, एक अज्ञात कारण से मुझे लगा कि हम सभी अद्वितीय पलिंडोम प्रदर्शित करने वाले थे, इसलिए मूल,। टिप के लिए धन्यवाद, तय!

— कलडो

Answer 6

स्टैक्स , 13 बाइट्स

绬►Ö∞j∞:Æ╘τδ

परीक्षण के मामले चलाएं (मेरी वर्तमान मशीन पर लगभग 10 सेकंड लगते हैं)

यह एक ही कार्यक्रम के संबंधित एएससीआई प्रतिनिधित्व है।

:e{cr=fw|Nc$cr=!

यह काफी शुद्ध जानवर-बल नहीं है, लेकिन यह मेरे द्वारा लिखे गए जानवर-बल के कार्यान्वयन जितना छोटा है। उस एक ने लगभग 10 मिनट के बाद मेरे ब्राउज़र को क्रैश कर दिया। वैसे भी, यहाँ यह कैसे काम करता है।

:e                  Get all contiguous substrings
  {cr=f             Keep only those that are palindromes
       w            Run the rest of the program repeatedly while a truth value is produced.
        |N          Get the next permutation.
          c$        Copy and flatten the permutation.
            cr=!    Test if it's palindrome.  If not, repeat.
                    The last permutation produced will be implicitly printed.

Answer 7

रूबी , 131 123 120 बाइट्स

->s{m=->t{t==t.reverse}
(1..z=s.size).flat_map{|l|(0..z-l).map{|i|s[i,l]}}.select(&m).permutation.map(&:join).detect &m}

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

एक लंबोदर एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। रिटर्न nilजब कोई समाधान मौजूद है।

-5 बाइट्स: select{|t|l[t]}साथ बदलेंselect(&l)

-3 बाइट्स: map{..}.flattenसाथ बदलेंflat_map{...}

-1 बाइट्स: स्थानापन्न लंबाई और सबरिंग ओवर लूप, स्टार्टिंग और ओवररिंग एंड के बजाय ओवररिंग स्टार्टिंग

-2 बाइट्स: zपहले से इस्तेमाल के बजाय पहले से घोषित करें

->s{
  l=->t{t==t.reverse}        # Lambda to test for palindromes
  (1..z=s.size).flat_map{|l| # For each substring length
    (0..z-l).map{|i|         # For each substring start index
      s[i,l]                 # Take the substring
    }
  }                          # flat_map flattens the list of lists of substrings
  .select(&l)                # Filter to include only palindromic substrings
  .permutation               # Take all orderings of substrings
  .map(&:join)               # Flatten each substring ordering into a string
  .detect &l                 # Find the first palindrome
}

Answer 8

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

h_I#sM.p_I#.:

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

-1 बाइट मिस्टर एक्सकोडर की बदौलत

Comments

Lol मुझे इतना यकीन था कि कोई और भी Pyth का उपयोग नहीं करता है कि मैंने अपना अलग उत्तर (अब हटा दिया गया) आपका देखने से पहले सबमिट किया था। आप 13 बाइट्स के लिए उपयोग कर सकते हैं h_I#sM.p_I#.:या कर सकते हैं e_IDsM.p_I#.:।

— श्री एक्सकोडर

@ Mr.Xcoder ओह हाहा: पी हाँ, मैं शायद ही कभी पायथ का उपयोग करता हूं, पता नहीं क्यों मैंने इसका उपयोग करने का फैसला किया। धन्यवाद!

— हाइपरएनुट्रिनो 16

Answer 9

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

lambda a:g(sum(k,[])for k in permutations(g(a[i:j+1]for i in range(len(a))for j in range(i,len(a)))))[0]
g=lambda k:[e for e in k if e==e[::-1]]
from itertools import*

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

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत

Comments

आप उपयोग कर सकते हैं a[i:j+1]यदि आप for j in range(i,len(a))इसके बजाय का उपयोग करते हैं, -2 बाइट्स के लिए।

— मिस्टर एक्सकोडर

Answer 10

जाप , 19 बाइट्स

जाप द्वारा बाधित (अभी तक) एक स्ट्रिंग के सभी सब्सट्रिंग प्राप्त करने में सक्षम नहीं है ( और आंशिक रूप से मेरी थकावट के वर्तमान द्वारा!)।

आउटपुट undefinedअगर कोई समाधान नहीं है।

Êõ@ãX fêQÃc á m¬æêQ

कोशिश करो

---

व्याख्या

                        :Implicit input of string U
Ê                       :Length of U
 õ                      :Range [1,Ê]
  @      Ã              :Pass each X through a function
   ãX                   :  Substrings of U of length X
      f                 :  Filter
       êQ               :    Is it a palindrome?
          c             :Flatten
            á           :Permutations
              m         :Map
               ¬        :  Join to a string
                æêQ     :Get first element that is a palindrome

Comments

क्या आपके प्रश्न को केवल ¬अपने उत्तर से हटाने के लिए प्रतिस्थापन की सूची के बारे में है : P?

— मैजिक ऑक्टोपस मूत्र

सोचा था कि मैं हटा सकता हूं, m¬लेकिन तब मुझे इसकी आवश्यकता होती, æ_¬êQइसलिए यह किसी भी बाइट को नहीं बचा सकता था!

— झबरा

हाहाहा, मैं अब से आपकी बाइट-सेविंग के तरीकों से सावधान रहना चाहता हूँ;)। मैंने खुद को जांचने के लिए इसे हटाने की कोशिश की, लेकिन एहसास हुआ कि जप्ट कमांड काम नहीं करते हैं जैसे मुझे लगता है कि वे काम करते हैं।

— मैजिक ऑक्टोपस Urn

Answer 11

भूसी , 12 बाइट्स

ḟS=↔mΣPfS=↔Q

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

व्याख्या

ḟS=↔mΣPfS=↔Q  Implicit input, a string.
           Q  List of substrings.
       f      Keep those
        S=↔   that are palindromic (equal to their reversal).
      P       Permutations of this list.
    mΣ        Flatten each.
ḟ             Find an element
 S=↔          that is palindromic.

Answer 12

जे , 53 बाइट्स

[:{:@(#~b"1)@(i.@!@#;@A.])@(#~(0<#*b=.]-:|.)&>)@,<\\.

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