"उप-palindromes" ढूँढना।

24

सबसे छोटा कोड जो एक स्ट्रिंग के सभी अनूठे "उप-पैलिन्ड्रोम" को ढूंढता है , वह है: लंबाई के साथ कोई भी विकल्प> 1 जो कि एक पैलिंड्रोम है।

eg.1

input: "12131331"
output: "33", "121", "131", "313", "1331"

eg.2

input: "3333"
output: "33", "333", "3333"
code-golf  string  palindrome  subsequence 
— Eelvex
स्रोत
1
क्या एक स्ट्रिंग हो सकता है कि वह स्वयं उप-तालबद्ध हो? एक स्ट्रिंग के बाद से यह स्वयं प्रतिस्थापन है।
— JPvdMerwe
@JPvdMerwe: हां, ऑफ कोर्स।
— बारह
वास्तव में अधिक महत्वपूर्ण बात: क्या उत्पादन होना 333चाहिए? Naively आप 33दो बार छपाई समाप्त करेंगे
— JPvdMerwe
@JPvdMerwe: '333' -> '33', '333'। मैं तदनुसार प्रश्न संपादित करूंगा। धन्यवाद।
— बारह
आउटपुट कैसे निर्दिष्ट किया जाता है? जैसे ही आप यहां प्रदर्शित करते हैं, कोमा-सीमांकित उद्धरण प्रत्येक उप-ताल के साथ होते हैं? प्रति पंक्ति एक उप-पी?
— जॉय

जवाबों:

11

जे, २४ ३१ ४०

~.(#~(1<#*]-:|.)&>),<\\.

नमूना उपयोग:

   ~.(#~(1<#*]-:|.)&>),<\\. '12131331'
┌───┬───┬───┬────┬──┐
│121│131│313│1331│33│
└───┴───┴───┴────┴──┘
   ~.(#~(1<#*]-:|.)&>),<\\. '3333'
┌──┬───┬────┐
│33│333│3333│
└──┴───┴────┘

वह लो, GolfScript!

— जेबी
स्रोत
इसे स्वीकार करें, आप /dev/randomहमें मूर्ख बनाने के लिए बस यहां से एक डंप डालते हैं ;-)
— जॉय
@ जोई इसे अपने लिए आज़माएं; पी (टीबीएच, मुझे विश्वास नहीं था कि यह या तो पहले काम कर सकता है)
— जेबी
मुझे पूरा यकीन है कि यह वास्तविक कोड है। मैंने सप्ताहांत में जे के आसपास अपना सिर लपेटने की कोशिश की, लेकिन बुरी तरह असफल रहा। फिर भी, मैं कोड पहचानता हूं; मुझे समझ में नहीं आता कि यह क्या करता है ;-)
— जॉय
2
क्या इसे ~.(#~(1<#*]-:|.)&>),<\\.(24 वर्ण) छोटा नहीं किया जा सकता है ?
— इब्राहीम
@ephemient यह वास्तव में करता है। (लगता है कि मैं "उत्तर में एक फ़ंक्शन होना चाहिए" मानसिकता में फंस गया था, जो यहां लागू नहीं होता है।) संपादित, धन्यवाद!
— जेबी
5

हास्केल 98, 88 91 96

import List
main=interact$show.filter(\x->length x>1&&x==reverse x).nub.(tails=<<).inits
— जेबी
स्रोत
3

अजगर - 138 136

यह कोड उप-palindromes की नकल नहीं करता है।

r=raw_input()
i,l=0,len(r)
j=l
a=[]
while i<l-1:
 t=r[i:j];j-=1
 if t==t[::-1]:a+=['"'+t+'"']
 if j<i+2:i+=1;j=l
print", ".join(set(a))
— JPvdMerwe
स्रोत
1
कुछ स्थान बचाने के '"'+t+'"'लिए बदलें t, हालांकि यह एकल उद्धरण का उपयोग करता है।
— थॉमस ओ
3

रूबी - 126 102 97 वर्ण

s=gets
*m=*0..s.size
puts m.product(m).map{|h,j|(c=s[h,j+1]).size>1&&c==c.reverse ? c:0}.uniq-[0]
— Nemo157
स्रोत
3

गोल्फस्क्रिप्ट, 48 वर्ण

subpalindrome.gs

{,}{(;}/{{,}{);}/}%{+}*{.,1>\.-1%=*},.&{`}%", "*

उपयोग:

echo "12131331" | ruby golfscript.rb subpalindrome.gs

पहला ऑपरेशन {,}{(;}/एक स्ट्रिंग को अनुगामी-सब्सट्रिंग्स की सूची में बदल देता है। एक समान अग्रणी- सबस्ट्रिंग ट्रांसफॉर्मेशन के बाद परिणाम पर मैप किया जाता है। फिर समतल करें {+}*, विधेय का उपयोग करते हुए पलिंड्रोम्स के लिए फ़िल्टर .,1>\.-1%=*करें .&, फिर सुंदर प्रिंट के साथ अद्वितीय मानों को पकड़ो ।

यह अनुगामी- सबस्ट्रिंग को ब्लॉक के रूप में तब्दील करने और इसे बदलने के लिए रिप्लेसमेंट के रूप में इसका उपयोग करने के लिए प्रत्येक ट्रेसिंग सबस्ट्रिंग को उलटने के बाद पुन: उपयोग करना होगा, लेकिन मैं ऐसा करने का एक अच्छा तरीका नहीं समझ सकता।

— roobs
स्रोत
2

हास्केल - 170 , 153

import Data.List
import Data.Set
p a=fromList$[show x|x<-subsequences a,x==reverse x,length x>1]
main=getLine>>=(\x->putStrLn$intercalate", "$toList$p x)
— जोनाथन स्टर्नबर्ग
स्रोत
बदलें main=getLine>>=(\x->putStrLn$intercalate", "$toList$p x)के साथ main=getLine>>=putStrLn.intercalate", ".toList.p। मैं pइसके शरीर के साथ कॉल का विकल्प भी चुनूंगा ।
— यासिर अर्सानुकेव
सबस्ट्रिंग / = subsequences! आपका कार्यक्रम उदाहरण के लिए संदर्भ आउटपुट की तुलना में अधिक उप-समूह की रिपोर्ट करता है। (उदाहरण के लिए "1111")
— जेबी
2

जे, ४ 48

f=:,@:".
h=:\\.
~.(#~10&<)((]h-:"0&f|.h)#[:f]h)

जैसे

~.(#~10&<)((]h-:"0&f|.h)#[:f]h) '12131331'
121 131 313 1331 33
— Eelvex
स्रोत
2

प्रस्तावना, ९ २

f(S,P):-append([_,X,_],S),X=[_,_|_],reverse(X,X),atom_codes(P,X).
p(S,R):-setof(P,f(S,P),R).

नमूना उपयोग:

?- p("12131331",R).
R = ['121', '131', '1331', '313', '33'].

?- p("3333",R).
R = ['33', '333', '3333'].
— जेबी
स्रोत
2

विंडोज पॉवरशेल, 104 109 111

0..($l=($s="$input").length-1)|%{($a=$_)..$l|%{-join$s[$a..$_]}}|sort -u|?{$_[1]-and$_-eq-join$_[$l..0]}

यह स्टड पर इनपुट की उम्मीद करता है और स्टडआउट पर एक लाइन में सभी पाए गए पैलिंड्रोम को फेंक देगा:

PS Home:\SVN\Joey\Public\SO\CG183> '12131331'| .\subp.ps1
33
121
131
313
1331

(जब इससे रन cmdबन जाता है echo 12131331|powershell -file subp.ps1- यह सिर्फ इतना है कि $inputस्क्रिप्ट को कैसे बुलाया गया था, इसके आधार पर थोड़ा अलग अर्थ लगता है, लेकिन यह स्टडिन हो सकता है, सिर्फ अंतःक्रियात्मक रूप से नहीं।

2011-01-30 13:57 (111) - पहला प्रयास।

2011-01-30 13:59 (109) - इच्छुक परिवर्तनीय घोषणा।

2011-06-02 13:18 (104) - कॉलिंग के बजाय एक चार सरणी में शामिल होने के द्वारा खोज को फिर से खोजें .Substring()और थोड़ा और अधिक झुकाएं।

— एक छोटा सा सिक्का
स्रोत
2

क्यू, 78

{a::x;(?)(,/)b@'(&:')({x~(|:)x}'')b:-1_1_'({(sublist[;a]')x,'1+c}')c::(!)(#)a}

प्रयोग

q){a::x;(?)(,/)b@'(&:')({x~(|:)x}'')b:-1_1_'({(sublist[;a]')x,'1+c}')c::(!)(#)a}"12131331"
"121"
"131"
"313"
"1331"
"33"
q){a::x;(?)(,/)b@'(&:')({x~(|:)x}'')b:-1_1_'({(sublist[;a]')x,'1+c}')c::(!)(#)a}"3333"
"33"
"333"
"3333"
— tmartin
स्रोत
2

रेटिना , 34 27 बाइट्स

&@!`(.)+.?(?<-1>\1)+(?(1)^)

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

परीक्षण सूट की जरूरत है Mक्योंकि परीक्षण के मामलों के बीच खाली लाइनों को सम्मिलित करने के लिए इसके बाद एक और चरण है।

व्याख्या

&@!`(.)+.?(?<-1>\1)+(?(1)^)

प्रिंट ( !) सभी अद्वितीय ( @), ओवरलैपिंग ( &) रेगेक्स के मैच (.)+.?(?<-1>\1)+(?(1)^)। यह संतुलन समूहों का उपयोग करके लंबाई 2 या उससे अधिक के एक ताल मेल खाता है। "सभी ओवरलैपिंग मैचों" भाग के लिए एक चेतावनी है: हम शुरुआती स्थिति में प्रति एक मैच प्राप्त कर सकते हैं। हालांकि, यदि अलग-अलग लंबाई के दो पलिंड्रोम्स एक ही स्थिति में शुरू होते हैं, तो छोटे पलिंड्रोम लंबे पैलिंड्रोम के अंत में फिर से दिखाई देंगे। और चूंकि +प्राथमिकता के लालच लंबे समय तक मेल खाते हैं, इसलिए हमें वैसे भी सभी पैलिंड्रोम मिल रहे हैं।

— मार्टिन एंडर
स्रोत
2

05AB1E , 11 10 बाइट्स

ŒÙʒÂQ}žQSK

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

— जादू ऑक्टोपस Urn
स्रोत
1
— स्कूटनीट
सिंगल्स के लिए @scottinet विफल, EG1234142141410010101000
— मैजिक ऑक्टोपस Urn
1
तुम्हारा भी, लेकिन उसी तरह से नहीं। o_O जांच की जरूरत है। इस बीच, यहां एक 10 बाइट्स संस्करण है जो काम करने लगता है
— स्कॉटीनेट
विशिष्ट के साथ एक बग था, मैंने इसे ठीक किया। अब आपके दोनों 11 बाइट्स जवाब और मेरे 9 बाइट्स एक काम :-)
— स्कूटनीट
@scottinet आपका 10-बटर 9-बटर होने के साथ-साथ बदल सकता 1›है ≠। :)
— केविन क्रूज़सेन
1

पर्ल, 112

$_=<>;chop;s/./$&$' /g;
map{/../&&$_ eq reverse&&$h{$_}++}split/ /
  for grep{s/./$`$& /g}split/ /;
print for keys %h
— ardnew
स्रोत
1

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

a=>{for(b=0,c=d=a.length,e=[];b<d;--c<b+2?(b++,c=d):1)(f=a.slice(b,c))==f.split``.reverse().join``&&e.push(f);return e}

यह फ़ंक्शन इनपुट के रूप में एक स्ट्रिंग लेता है और एक सरणी आउटपुट करता है।

— ल्यूक
स्रोत
1

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

#(set(for[i(range 2(+(count %)1))p(partition i 1 %):when(=(reverse p)(seq p))]p))

forयहाँ एक परिपूर्ण मैच था :) :when(=(reverse p)p)अगर इनपुट वर्णों की एक सूची का उपयोग कर सकता था या एक पूर्ण स्ट्रिंग को एक पैलिंड्रोम के रूप में नहीं गिना जाता था, तो वास्तव में उस स्थिति में अधिकतम रेंज भी iहो सकती थी (count %)।

संदर्भ के लिए सबसे कॉम्पैक्ट मामला:

#(set(for[i(range 2(count %))p(partition i 1 %):when(=(reverse p)p)]p))
— NikoNyrh
स्रोत
1

पायथन, 83 102 चार्ट

s=lambda t:(t[1:]or())and(t,)*(t==t[::-1])+s(t[1:])+s(t[:-1])
print set(s(input()))

मुहावरा (t[1:]or())and...(...)if t[1:]else() एक वर्ण के बराबर है और बचाता है! मुझे इस पर गर्व है, बचत को देखते हुए।

उदाहरण:

python x
"51112232211161"
set(['11', '22', '11122322111', '161', '111', '112232211', '1223221', '22322', '232'])
— boothby
स्रोत
1

स्काला 127

object p extends App{val s=args(0);print(2.to(s.size).flatMap(s.sliding(_).toSeq.filter(c=>c==c.reverse)).toSet.mkString(" "))}

इस सेब को अन्य स्काला उत्तर के साथ तुलना करने के लिए सेब रखने के लिए, मैंने अपना एक ऑब्जेक्ट भी बनाया जो ऐप का विस्तार करता है। मैन्युअल रूप से इनपुट स्ट्रिंग को पुनरावृत्त करने के बजाय और सबस्ट्रिंग का उपयोग करें, मैंने मेरे लिए सभी सबस्ट्रिंग का एक क्रम बनाने के लिए स्लाइडिंग () का लाभ उठाया।

— bkuder
स्रोत
1

स्काला 156 170

object o extends App{val l=args(0).length-2;val r=for(i<-0 to l;j<-i to l;c=args(0).substring(i,j+2);if(c==c.reverse))yield c;print(r.toSet.mkString(" "))}


object o{def main(s:Array[String]){val l=s(0).length-2;val r=for(i<-0 to l;j<-i to l;c=s(0).substring(i,j+2);if(c==c.reverse)) yield c;println(r.distinct.mkString(" "))}}

— ललित
स्रोत
हाय ललित, मैंने आपका कोड थोड़ा छोटा कर दिया है: उपज से पहले कोई खाली नहीं है और ओवरराइटिंग के बजाय ऐप को अधिलेखित करने के बजाय मुख्य, Println => प्रिंट और विशिष्ट => toSet
— उपयोगकर्ता अज्ञात
1

पर्ल 6 ,  35  32 बाइट्स

{unique ~«m:ex/(.+).?<{$0.flip}>/}

झसे आज़माओ

{set ~«m:ex/(.+).?<{$0.flip}>/}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  set             # turn into a Set object (ignores duplicates)

  ~«\             # stringify ｢~｣ all of these ｢«｣ (possibly in parrallel)
                  # otherwise it would be a sequence of Match objects

  m               # match
  :exhaustive     # in every way possible
  /
    ( .+ )        # at least one character ｢$0｣
    .?            # possibly another character (for odd sized sub-palindromes)
    <{ $0.flip }> # match the reverse of the first grouping
  /
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
1

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

ẆQŒḂÐfḊÐf

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

— आउटगोल्फर को एरिक करें
स्रोत
आपके पर्मलिंक का आउटपुट गलत है।
— डेनिस
@Dennis क्यों यह तो एक शिकार लक्ष्य बन गया> _> तय
— एरिक Outgolfer
नई जेली के साथ 7 बाइट्स।
— user202729
1

APL (Dyalog Classic) , 27 बाइट्स

{∪⍵/⍨≡∘⌽¨⍨⍵}∘⊃(,/1↓⍳∘≢,/¨⊂)

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

{∪⍵/⍨≡∘⌽¨⍨⍵}∘⊃(,/1↓⍳∘≢,/¨⊂)    Monadic train:
                           ⊂     Enclose the input, ⊂'12131331'
                     ⍳∘≢          Range from 1 to length of input
                     ⍳∘≢,/¨⊂      List of list of substrings of each length
                   1↓            Remove the first list (length-1 substrings)
               ⊃ ,/              Put the rest of the substrings into a single list.
{∪⍵/⍨≡∘⌽¨⍨⍵}                   To the result, apply this function which
                                   keeps all palindromes from a list:
      ≡∘⌽¨⍨⍵                    Boolean value of whether each (¨) string in argument
      ≡∘⌽ ⍨                     is equal to its own reverse

  ⍵/⍨                           Replicate (filter) argument by those values.
                                 This yields the length >1 palindromes.
∪                                Remove duplicates from the list of palindromes.
— lirtosiast
स्रोत
ओपी को "कोड" के लिए कॉल करने के कारण, स्निपेट ∪w/⍨≡∘⌽¨⍨w←⊃,/1↓(⍳∘≢,/¨⊂)मान्य है।
— 9
@ मुझे लगता है कि मैं इस जवाब को रखूंगा क्योंकि यह आधुनिक साइट मानकों के लिए है, खासकर जब से इसे समग्र जीत नहीं मिली है।
— 19
1

Brachylog , 11 बाइट्स

{s.l>1∧.↔}ᵘ

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

(लिंक में शीर्षलेख पोस्टिंग के समय टूट गया है, इसलिए यहां केवल पहले परीक्षण मामले पर विधेय (ब्रैकीलॉग में फ़ंक्शन-समतुल्य) एक के साथ है,w आउटपुट प्रिंट करने के लिए अंत में है।)

               The output is
{        }ᵘ    a list containing every possible unique
 s.            substring of
               the input
   l           the length of which
    >          is greater than
     1         one
      ∧        and
       .       which
        ↔      reversed
               is itself. (implicit output within the inline sub-predicate)

मुझे लगता है कि यह जाँचने का एक छोटा तरीका है कि लंबाई 1. से अधिक है (यदि यह तुच्छ पलिंड्रोम्स को फ़िल्टर नहीं करता है, तो यह बस होगा {s.↔}ᵘ।)

— असंबंधित स्ट्रिंग
स्रोत
1

एपीएल (एनएआरएस), 65 चार्ट, 130 बाइट्स

{0=≢m←∪b/⍨{1≥≢⍵:0⋄∧/⍵=⌽⍵}¨b←↑∪/{x[⍵;]⊂y}¨⍳≢x←11 1‼k k⊢k←≢y←⍵:⍬⋄m}

परीक्षा:

  r←{0=≢m←∪b/⍨{1≥≢⍵:0⋄∧/⍵=⌽⍵}¨b←↑∪/{x[⍵;]⊂y}¨⍳≢x←11 1‼k k⊢k←≢y←⍵:⍬⋄m}
  o←⎕fmt
  o r '1234442'
┌2───────────┐
│┌2──┐ ┌3───┐│
││ 44│ │ 444││
│└───┘ └────┘2
└∊───────────┘
  o r '3333'
┌3───────────────────┐
│┌4────┐ ┌3───┐ ┌2──┐│
││ 3333│ │ 333│ │ 33││
│└─────┘ └────┘ └───┘2
└∊───────────────────┘
  o r  "12131331"
┌5─────────────────────────────────┐
│┌4────┐ ┌3───┐ ┌2──┐ ┌3───┐ ┌3───┐│
││ 1331│ │ 121│ │ 33│ │ 313│ │ 131││
│└─────┘ └────┘ └───┘ └────┘ └────┘2
└∊─────────────────────────────────┘
  o r '1234'
┌0─┐
│ 0│
└~─┘


{0=≢m←∪b/⍨{1≥≢⍵:0⋄∧/⍵=⌽⍵}¨b←↑∪/{x[⍵;]⊂y}¨⍳≢x←11 1‼k k⊢k←≢y←⍵:⍬⋄m}
 y←⍵  assign the argument to y (because it has to be used inside other function)
 x←11 1‼k k⊢k←≢y   assign the lenght of y to k, call the function 11 1‼k k
                   that seems here find all partition of 1 2 ..k
 {x[⍵;]⊂y}¨⍳≢      make partition of arg ⍵ using that set x
 ∪/                set union with precedent to each element of partition y (i don't know if this is ok)
 b←↑               get first assign to b
 {1≥≢⍵:0⋄∧/⍵=⌽⍵}¨ for each element of b return 1 only if the argument ⍵ is such that 
                   "∧/⍵=⌽⍵" ⍵ has all subset palindrome, else return 0
 b/⍨               get the elements in b for with {1≥≢⍵:0⋄∧/⍵=⌽⍵} return 1
 m←∪               make the set return without ripetition element, and assign to m
 0=≢               if lenght of m is 0 (void set) than 
 :⍬⋄m              return ⍬ else return m

यह किसी को बेहतर पता है क्यों, और इसे बेहतर तरीके से समझा सकता है, इस परिवर्तन से मुक्त ... मैं इस कोड के बारे में इतना निश्चित नहीं हूं, संभव है कि यदि परीक्षण के उदाहरण अधिक हैं, तो कुछ गलत हो जाएगा ...

— RosLuP
स्रोत
0

जावा 8, 202 201 199 बाइट्स

import java.util.*;s->{Set r=new HashSet();String x;for(int l=s.length(),i=0,j;i<l;i++)for(j=i;++j<=l;)if((x=s.substring(i,j)).contains(new StringBuffer(x).reverse())&x.length()>1)r.add(x);return r;}

इसे यहाँ आज़माएँ।

यदि किसी कार्य की अनुमति नहीं है और पूर्ण कार्यक्रम की आवश्यकता है, तो इसके बजाय 256 255 253 बाइट्स हैं:

import java.util.*;interface M{static void main(String[]a){Set r=new HashSet();String x;for(int l=a[0].length(),i=0,j;i<l;i++)for(j=i;++j<=l;)if((x=a[0].substring(i,j)).contains(new StringBuffer(x).reverse())&x.length()>1)r.add(x);System.out.print(r);}}

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

import java.util.*;      // Required import for Set and HashSet

s->{                     // Method with String parameter and Set return-type
  Set r=new HashSet();   //  Return-Set
  String t;              //  Temp-String
  for(int l=s.length(),  //  Length of the input-String
          i=0,j;         //  Index-integers (start `i` at 0)
      i<l;i++)           //  Loop (1) from `0` to `l` (exclusive)
    for(j=i;++j<=l;)     //   Inner loop (2) from `i+1` to `l` (inclusive)
      if((t=s.substring(i,j) 
                         //    Set `t` to the substring from `i` to `j` (exclusive)
         ).contains(new StringBuffer(t).reverse())
                         //    If this substring is a palindrome,
         &t.length()>1)  //    and it's length is larger than 1:
        r.add(t);        //     Add the String to the Set
                         //   End of inner loop (2) (implicit / single-line body)
                         //  End of loop (1) (implicit / single-line body)
  return r;              //  Return the result-Set
}                        // End of method
— केविन क्रूज़सेन
स्रोत
0

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

एक सेट लौटाता है ।

s=>new Set((g=(s,r=[...s].reverse().join``)=>s[1]?(r==s?[s]:[]).concat(g(s.slice(1)),g(r.slice(1))):[])(s))

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

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

— Arnauld
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.