बिल्कुल सही Palindromes

25

आपका कार्य यह निर्धारित करना है कि एक स्ट्रिंग कितना सही तालमेल है। आपका विशिष्ट पैलिंड्रोम (जैसे 12321) एक परिपूर्ण पैलिंड्रोम है; इसकी पूर्णता 1 है।

एक स्ट्रिंग की पूर्णता निर्धारित करने के लिए, आप देखते हैं कि आप इसे कितने खंडों में विभाजित कर सकते हैं, जहां प्रत्येक अनुभाग एक पैलिंड्रोम है। वहाँ इस तरह के साथ के रूप में अस्पष्टता, कर रहे हैं aaaa, जैसा कि आप इसे में विभाजित कर सकते हैं [aa, aa]या [aaaa]या [a, aaa]या [aaa, a], कम से कम सेट को पार कर जाएगी, दे रही है aaaa1 के स्कोर है, जो कम से कम सेट की लंबाई है।

इसलिए, आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो एक गैर-खाली इनपुट और आउटपुट लेगा कि यह कितना सही है (जो कि सबसे कम सेट की लंबाई है आप इसे विभाजित कर सकते हैं जहां सेट में प्रत्येक तत्व एक पैलिंड्रोम है)।

उदाहरण:

1111 -> 1 [1111]
abcb -> 2 [a, bcb]
abcbd -> 3 [a, bcb, d]
abcde -> 5 [a, b, c, d, e]
66a -> 2 [66, a]
abcba-> 1 [abcba]
x -> 1 [x]
ababacab -> 2 [aba, bacab]
bacababa -> 2 [bacab, aba]
26600 -> 3 [2, 66, 00] [my user id] [who has a more perfect user id?]
ababacabBACABABA -> 4 [aba, bacab, BACAB, ABA]

ध्यान दें कि उदाहरणों में वर्ग कोष्ठक में कुछ भी आउटपुट का हिस्सा नहीं होना चाहिए।

code-golf  string  palindrome 
— Okx
स्रोत
क्या रिक्त स्ट्रिंग एक वैध इनपुट है, और यदि हां, तो आउटपुट क्या होना चाहिए?
— जर्गर्ब
8
ababacabऔर इसके विपरीत, bacababaअच्छे परीक्षण के मामले प्रतीत होते हैं।
— नील
@Neil साथ ही साथ अच्छे तर्क हैं कि क्या एक रैखिक-समय एल्गोरिथ्म संभव है।
— लीक नून
@Zgarb खाली स्ट्रिंग मान्य इनपुट नहीं है।
— ओकेक्स
ababacabBACABABAएक अच्छा परीक्षण मामला भी है (कुछ उत्तर उस पर विफल हैं)।
— जर्गर्ब

जवाबों:

14

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

~cL↔ᵐLl

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

व्याख्या

~cL          Deconcatenate the input into L
  L↔ᵐL       Reversing all elements of L results in L
     Ll      Output = length(L)
— Fatalize
स्रोत
आपने मुझे हरा दिया ... मेरी पहली पोस्ट
— लीकी नून
7
@LeakyNun मुझे पता था कि आप इसे आजमाएंगे। पिछले महीने मैं कुछ घंटे रुक सकता था, अब आपके साथ मुझे तुरंत जवाब देना होगा!
— घातक
9

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

ŒṖLŒṖ € P $ ḢfḢL 
ÞṚL⁼ € Ð $ ÞŒḂfḢL
ŒṖṚ € ⁼ $ DFL € मीटर
ŒṖ विभाजन प्राप्त करते हैं
      विभाजन के लिए partf फ़िल्टर जो
  Part प्रत्येक अवतरण को उलटने के बाद
    The विभाजन के बराबर है
        प्रत्येक सफल विभाजन की लंबाई successful एल
          Ṃ न्यूनतम

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

चश्मा

  • इनपुट: "ababacab" (तर्क के रूप में)
  • आउटपुट: 2
— लीक नन
स्रोत
3
@ ओके अच्छी तरह से आपको उन से बचना होगा।
— लीकी नून
2
ठीक है, मुझे नहीं लगता कि यह मान्य है अगर यह बैकस्लैश स्वीकार नहीं कर सकता।
— ओकेक्स
14
@Okx यह एक स्ट्रिंग लिखने जैसा है। आप एक स्ट्रिंग इनपुट के साथ काम करने के लिए C प्रोग्राम की उम्मीद नहीं कर सकते "\", क्योंकि यह अमान्य सिंटैक्स है।
— कॉनर ओ'ब्रायन
2
वापस स्वागत है, वैसे। :-)
— अरनौलद
2
अफसोस की बात है कि यह अलग-अलग जवाब देता है ababacabऔर इसके विपरीत bacababa,।
— नील
6

अजगर, 9 बाइट्स

lh_I#I#./

परीक्षण सूट

यह सबसे छोटे से लेकर सबसे लंबे समय तक इनपुट के सभी विभाजन बनाता है। फिर, यह उन विभाजनों को फ़िल्टर करता है जो व्युत्क्रम पर तत्वों को फ़िल्टर करने के तहत उलटा करते हैं। अंत में, हम विभाजन की फ़िल्टर्ड सूची का पहला तत्व लेते हैं, और इसकी लंबाई वापस करते हैं।

उस जटिल कदम की व्याख्या करने के लिए, आइए उलटा पड़ने वाले आक्रमण के साथ शुरू करें _I:। यह जाँचता है कि क्या इसका इनपुट एक पैलिंड्रोम है, क्योंकि यह जाँचता है कि क्या पलटाव मूल्य को बदलता है।

अगला, छीलने के लिए फ़िल्टरिंग _I#:। यह सूची के केवल पैलिंड्रोमिक तत्वों को रखेगा।

अगला, हम palindromicity के लिए फ़िल्टरिंग के तहत invariance की जाँच करते हैं _I#I:। यह सत्य है यदि और केवल यदि सूची के सभी तत्व palindromes हैं।

अंत में, हम उन सूचियों के लिए फ़िल्टर करते हैं जहाँ सूची के सभी तत्व पलिंड्रोम हैं _I#I#:।

— isaacg
स्रोत
मुझे बहुत कुछ सीखने को मिला है ...
— Leaky Nun
6

हास्केल , 83 बाइट्स

f s=minimum[length x|x<-words.concat<$>mapM(\c->[[c],c:" "])s,all((==)=<<reverse)x]

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

यह स्ट्रिंग विभाजन उत्पन्न करने के लिए ज़गारब के शानदार टिप का उपयोग करता है ।

f s = minimum[                               -- take the minimum of the list
    length x |                               -- of the number of partitions in x
    x<-words.concat<$>mapM(\c->[[c],c:" "])s -- where x are all partitions of the input string s
    , all((==)=<<reverse)x                   -- where each partition is a palindrome.
]
— Laikoni
स्रोत
1
वाह! इसने मेरा दिमाग उड़ा दिया! मुझे निश्चित रूप से बहुत कुछ सीखने को मिला।
— मेपल_शाफ्ट
5

क्लोजर, 111 बाइट्स

(defn f[s](if(=()s)0(+(apply min(for[i(range(count s))[a b][(split-at(inc i)s)]:when(=(reverse a)a)](f b)))1)))

सभी संभावित पदों पर विभाजन, और जब पहला भाग एक पैलिंड्रोम आय है, तो स्ट्रिंग के शेष के लिए एक विभाजन खोजने के लिए।

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

Ungolfed, थ्रेड-अंतिम मैक्रो का उपयोग करता है ->>।

(defn f [s]
  (if (empty? s)
    0
    (let [results (for[i (range(count s))]
                      (let [[a b] (split-at (inc i) s)]
                         (when (= a (reverse a))
                           (f b))))]
      (->> results        ; Take results (a list of integers and nils),
           (filter some?) ; remove null values (they occur when "a" is not a palindrome)
           (apply min)    ; find the minium value,
           inc))))        ; and increment by one.

एक अस्पष्ट संस्करण, कृपया इस तरह कोड न लिखें: डी

(defn f [s]
   (->> (f b)
        (when (= a (reverse a)))
        (let [[a b] (split-at (inc i) s)])
        (for[i (range(count s))])
        (filter some?)
        (apply min)
        inc
        (if (empty? s) 0)))
— NikoNyrh
स्रोत
क्या यह टिप मदद करेगी ? मैं क्लोजर को बिल्कुल नहीं जानता।
— लीक नून
आमतौर पर हाँ, लेकिन इस मामले में समारोह fके लिए भीतर ही कॉल करने के लिए है: (f b)। टेल-कॉल स्थिति पर आप उपयोग कर सकते हैं recur।
— निकोनिर
तुम अब भी जगह ले सकता है defnके साथ fnऔर सिर्फ एक समारोह है।
— क्लिफरॉट
(fn f[s]( ... ))? अरे सच है। आप उस के साथ 2 अक्षर बचाते हैं।
— निकोनिरह
5

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

नील को धन्यवाद देकर 2 बाइट्स बचाए

NikoNyrh विधि से प्रेरित है ।

s=>(r=1/0,F=(s,i=1,p=0)=>s[p++]?([...o=s.slice(0,p)].reverse().join``==o&&(s[p]?F(s.slice(p),i+1):r=r<i?r:i),F(s,i,p)):r)(s)

प्रारूपित और टिप्पणी की गई

s => (                          // given a string 's':
  r = 1 / 0,                    // 'r' = best score, initialized to +Infinity
  F = (                         // 'F' is a recursive function that takes:
    s,                          //   - the current string 's'
    i = 1,                      //   - a substring counter 'i'
    p = 0                       //   - a character pointer 'p'
  ) =>                          //
    s[p++] ? (                  // if we haven't reached the end of the string:
      [...o = s.slice(0, p)]    //   compute 'o' = substring of length 'p'
      .reverse().join`` == o    //   if 'o' is a palindrome,
      && (                      //   then:
        s[p] ?                  //     if there are still characters to process:
          F(s.slice(p), i + 1)  //       do a recursive call on the remaining part
        :                       //     else:
          r = r < i ? r : i     //       update the score with r = min(r, i)
      ),                        //   in all cases:
      F(s, i, p)                //     do a recursive call with a longer substring
    ) :                         // else:
      r                         //   return the final score
  )(s)                          // initial call to F()

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

कोड स्निपेट दिखाएं

प्रारंभिक दृष्टिकोण, 173 168 बाइट्स

एक बहुत लंबा पुनरावर्ती कार्य जो इनपुट स्ट्रिंग के सभी संभावित विभाजन की गणना करता है।

f=(s,b=1/(k=0))=>++k>>(L=s.length)?b:f(s,(k|1<<30).toString(2).slice(-L).match(/(.)\1*/g).some(m=>[...o=s.slice(i,i+=m.length)].reverse(n++).join``!=o,n=i=0)?b:b<n?b:n)

प्रारूपित और टिप्पणी की गई

f = (                           // given:
  s,                            //   - a string 's'
  b = 1 / (k = 0)               //   - a best score 'b' (initialized to +Infinity)
) =>                            //   - a counter 'k' (initialized to 0)
  ++k >> (L = s.length) ?       // if 'k' is greater or equal to 2^(s.length):
    b                           //   stop recursion and return 'b'
  :                             // else:
    f(                          //   do a recursive call:
      s,                        //     using the same string 's'
      (k | 1 << 30)             //     compute an array containing the groups of identical
      .toString(2).slice(-L)    //     digits in the binary representation of 'k', padded
      .match(/(.)\1*/g)         //     with leading zeros and cut to the length of 's'
      .some(g =>                //     for each group 'g' in this array:
        [... o = s.slice(       //       compute 'o' = corresponding substring of 's',
          i, i += g.length      //       starting at position 'i' with the same length
        )]                      //       (e.g. s = 'abcd' / k = 0b1101 => 'ab','c','d')
        .reverse(n++)           //       increment the number of groups 'n'
        .join`` != o,           //       return true if this substring is NOT a palindrome
        n = i = 0               //       initialize 'n' and 'i'
      ) ?                       //     if some() returns true:
        b                       //       invalid partition -> keep the previous score 'b'
      :                         //     else:
        b < n ? b : n           //       valid partition -> use min(b, n)
    )                           //   end of recursive call

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
अगर मैंने आपके स्पष्टीकरण को सही ढंग से समझा है, तो आप कुछ बाइट्स का उपयोग करके बचा सकते हैं ,p=0, s[p++]?और ,F(s,i,p)।
— नील
@ नील वास्तव में हाँ। :-)
— अरनौलद
5

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

ŒṖŒḂ€¬$ÞḢL

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

कैसे?

इस तथ्य का उपयोग करता है कि
[0]<[0,0]<[0,0,0],...,<[0,...,0,1]<...
- इस प्रकार यदि हम एक कुंजी द्वारा विभाजनों को छाँटते हैं "प्रत्येक भाग के लिए पैलिंड्रोमिक नहीं है" पहली प्रविष्टि सभी पैलिंड्रोमिक और न्यूनतम लंबाई होगी।

नोट: लंबाई n का कोई भी गैर-रिक्त स्ट्रिंग हमेशा n शून्य के साथ इस तरह की कुंजी का परिणाम होगा , क्योंकि सभी लंबाई 1 तार palindromic हैं।

ŒṖŒḂ€¬$ÞḢL - Main link: s             e.g. 'abab'
ŒṖ         - partitions of s               [['a','b','a','b'],['a','b','ab'],['a','ba','b'],['a','bab'],['ab','a','b'],['ab','ab'],['aba','b'],['abab']]
       Þ   - sort by (create the following key and sort the partitions by it):
      $    -   last two links as a monad:  (key evaluations aligned with above:)
  ŒḂ€      -     is palindromic? for €ach   [ 1 , 1 , 1 , 1 ] [ 1 , 1 , 0  ] [ 1 , 0  , 1 ] [ 1 , 1   ] [ 0  , 1 , 1 ] [ 0  , 0  ] [ 1   , 1 ] [ 0    ] 
     ¬     -     not                        [ 0 , 0 , 0 , 0 ] [ 0 , 0 , 1  ] [ 0 , 1  , 0 ] [ 0 , 0   ] [ 1  , 0 , 0 ] [ 1  , 1  ] [ 0   , 0 ] [ 1    ]
           - ...i.e.:         
           -       making the sorted keys: [[ 0 , 0   ],[ 0   , 0 ],[ 0 , 0 , 0 , 0 ],[ 0 , 0 , 1  ],[ 0 , 1  , 0 ],[ 1    ],[ 1  , 0 , 0 ],[ 1  , 1  ]]
           -  hence the sorted partitions: [['a','bab'],['aba','b'],['a','b','a','b'],['a','b','ab'],['a','ba','b'],['abab'],['ab','a','b'],['ab','ab']]
        Ḣ  - head of the result             ['a','bab']
         L - length                         2
— जोनाथन एलन
स्रोत
5

हास्केल , 69 बाइट्स

x!(a:b)|p<-a:x=p!b++[1+f b|p==reverse p]
x!y=[0|x==y]
f=minimum.(""!)

एक कार्य को परिभाषित करता है f। इसे ऑनलाइन आज़माएं!

व्याख्या

इनफ़िक्स हेल्पर फ़ंक्शन x ! yपूर्णांक की एक सूची की गणना करता है, जो कि पैलिंड्रोम में कुछ बंटवारे की लंबाई होती है, reverse x ++ yजहां reverse xबरकरार रहती है। यह yगैर-खाली होने पर न्यूनतम विभाजन की लंबाई को समाहित करने की गारंटी है। यह कैसे काम करता है।

  • यदि yकोई गैर-रिक्त है, तो एक चार्ट को बंद कर दिया जाता है और उसमें धकेल दिया जाता है x। यदि xएक पलिंड्रोम बन जाता है, तो हम मुख्य कार्य fको पूंछ की तरफ कहते हैं yऔर खाते में 1 जोड़ते हैं x। इसके अलावा, हम !नए पर कॉल करते हैं xऔर yकिसी भी संभावित विभाजन को याद नहीं करते हैं।
  • यदि yखाली है, तो हम लौटते हैं [0](लंबाई का एक बंटवारा 0) यदि xखाली भी है, और [](कोई विभाजन नहीं)।

मुख्य कार्य fसिर्फ कॉल करता है "" ! xऔर न्यूनतम परिणाम लेता है।

x!(a:b)|          -- Function ! on inputs x and list with head a and tail b,
  p<-a:x=         -- where p is the list a:x, is
  p!b++           -- the numbers in p!b, and
  [1+f b|         -- 1 + f b,
   p==reverse p]  -- but only if p is a palindrome.
x!y=              -- Function ! on inputs x and (empty) list y is
  [0|             -- 0,
   x==y]          -- but only if x is also empty.
f=                -- Function f is:
  minimum.(""!)   -- evaluate ! on empty string and input, then take minimum.
— Zgarb
स्रोत
3

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 97 बाइट्स

f=(s,t=``,i=0)=>s?Math.min(...(for(c of s)if([...t+=c].reverse(++i).join``==t)1+f(s.slice(i)))):0

ES6 पोर्ट:

f=(s,t=``)=>s?Math.min(...[...s].map((c,i)=>[...t+=c].reverse().join``==t?1+f(s.slice(i+1)):1/0)):0
<input oninput=o.textContent=f(this.value)><pre id=o>
स्निपेट का विस्तार करें

यह इतना सरल समाधान लगता है कि मुझे लगता है कि मैं कुछ भूल गया हूं, लेकिन यह कम से कम सभी परीक्षण मामलों को पारित करता है।

— नील
स्रोत
1

हास्केल, 139 116 109 बाइट्स

h[]=[[]]
h x=words.concat<$>mapM(\c->[[c],c:" "])x
r x=reverse x==x
g x=minimum[length y|y<-h x,and$r<$>y]

हास्केल गोल्फ में अभी भी हरा है लेकिन यहां मेरा सबसे अच्छा प्रयास है कि मैं जल्दी से आ सकूं।

  • h एक ऐसा फंक्शन है जो एक लिस्ट के सभी संभावित सन्दर्भों की सूची बनाता है (जैसे एक स्ट्रिंग)। यह इनपुट स्ट्रिंग लेता है और इसे जी के लिए तोड़ता है।
  • r एक साधारण कार्य है जो एक सूची के लिए एक बूलीयन देता है
  • g एक मुख्य कार्य है जो एक इनपुट सूची लेता है, सन्निहित बाद की संभावनाओं की सूची प्राप्त करने के लिए h को कॉल करता है, (and.map r)उप सूचियों को हटाने के लिए फ़िल्टर करता है जिसमें एक palindrome नहीं होता है, जिस बिंदु पर सूची में लंबाई लागू होती है, और फिर परिणाम होता है हल किया गया है तो हम सिर पकड़ सकते हैं जो उत्तर है।

मैं सोच रहा था कि बेहतर उत्तर हो सकता है कि आवेदकों के उपयोग के माध्यम से हास्केल में सूचियों के गैर-निर्धारक प्रकृति का लाभ उठाने में सक्षम हो। यदि हमे Control.Applicative को इम्पोर्ट करना है, तो भी एप्लिकेशन को उपयोग करके फंक्शन h के कई बाइट्स शेव करना संभव हो सकता है। सुधार के लिए टिप्पणियाँ स्वागत योग्य हैं।

Update1

न्यूनतम समारोह के बारे में लकोनी के अनुस्मारक पर आधारित बड़ी बचत। सॉर्ट हटाने से मुझे वास्तव में Data.List आयात को छोड़ने की अनुमति मिली क्योंकि न्यूनतम Prelude में परिभाषित किया गया है!

UPDATE2

फ़िल्टर के लिए एक उपयोगी प्रतिस्थापन के रूप में सूची की समझ का उपयोग करने के बारे में नीमी के सुझाव के लिए धन्यवाद। इसने मुझे कुछ बाइट्स से बचाया। इसके अलावा, मैंने लाइकोनिस के उत्तर से स्वच्छ स्ट्रिंग विभाजन की चाल उधार ली और साथ ही कुछ युगल बाइट भी बचाए।

— maple_shaft
स्रोत
1
h []=[[]]और h (x:y)=map ([x]:)अनावश्यक सफेद स्थान होते हैं। head.sortहै minimum।
— लकोनी
@ लायकोनी धन्यवाद! जब मैं अपने कंप्यूटर पर वापस आऊंगा तो मैं अपडेट करूंगा!
— मेपल_शाफ्ट
1
एक सूची समझ अक्सर filter& map: से कम होती है g x=head$sort[length y|y<-h x,and$r<$>y]।
— निमि
@nimi धन्यवाद, हास्केल के लिए बहुत सारे उपयोगी गोल्फ युक्तियाँ हैं। मैं हर बार एक नई चाल सीखता हूं।
— मेपल_शफ्ट
1

PHP, 319 बाइट्स

for(;$i<$l=strlen($s=$argn);$i++)for($j=$l-$i;$j;$j--)strrev($r=substr($s,$i,$j))!=$r?:$e[+$i][]=$r;uasort($e,function($a,$b){return strlen($b[0])<=>strlen($a[0])?:count($a)<=>count($b);});foreach($e as$p=>$v)foreach($v as$w){$s=preg_replace("#^(.{{$p}})$w#","$1".str_pad("",strlen($w),"ö"),$s,1,$c);!$c?:++$d;}echo$d;

ऑनलाइन संस्करण

विस्तारित

for(;$i<$l=strlen($s=$argn);$i++)
for($j=$l-$i;$j;$j--)strrev($r=substr($s,$i,$j))!=$r?:$e[+$i][]=$r; #Make all substrings that are palindromes for each position
uasort($e,function($a,$b){return strlen($b[0])<=>strlen($a[0])?:count($a)<=>count($b);}); # sort palindrome list high strlen lowest count for each position
foreach($e as$p=>$v)
foreach($v as$w){
    $s=preg_replace("#^(.{{$p}})$w#","$1".str_pad("",strlen($w),"ö"),$s,1,$c);
    !$c?:++$d; # raise count
}
echo$d; # Output

E_NOTICE और आउटपुट परिणाम के बिना लंबा संस्करण

— जार्ग हुल्सरमन
स्रोत
यह गलत परिणाम देने के लिए लगता हैababacabBACABABA
— Zgarb
@Zgarb अब यह काम करता है
— Jörg Hülsermann
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.