स्ट्रिंग्स को पालिंड्रोमाइज करना

30

परिचय

जो लोग नहीं जानते हैं, उनके लिए एक पैलिंड्रोम तब होता है जब एक स्ट्रिंग पीछे की ओर स्ट्रिंग के बराबर होती है (इंटरपंक्शन, रिक्त स्थान आदि के अपवाद के साथ)। पैलेंड्रोम का एक उदाहरण है:

abcdcba

यदि आप इसे उल्टा करते हैं, तो आप समाप्त हो जाएंगे:

abcdcba

जो समान है। इसलिए, हम इसे एक पैलिंड्रोम कहते हैं। चीजों को पलटने के लिए, आइए एक स्ट्रिंग के उदाहरण पर नज़र डालें:

adbcb

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

पहली चीज़ जो हम आज़मा सकते हैं, वह है:

adbcb
bcbda
^^ ^^

सभी वर्ण मेल नहीं खाते हैं, इसलिए यह उलट स्ट्रिंग के लिए सही स्थिति नहीं है। हम एक कदम दाईं ओर जाते हैं:

adbcb
 bcbda
 ^^^^

यह भी सभी वर्णों से मेल नहीं खाता है। हम दाईं ओर एक और कदम बढ़ाते हैं:

adbcb
  bcbda

इस बार, सभी वर्ण मेल खाते हैं । हम दोनों स्ट्रिंग को बरकरार रखते हुए विलय कर सकते हैं । अंतिम परिणाम है:

adbcbda

यह पैलिंड्रोमाइज्ड स्ट्रिंग है ।

काम

एक स्ट्रिंग (कम से कम एक वर्ण के साथ) को केवल लोअरकेस अक्षर (या अपरकेस, यदि वह बेहतर रूप से फिट बैठता है) को देखते हुए, पैलिंड्रोमाइज्ड स्ट्रिंग को आउटपुट करता है ।

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

Input     Output

abcb      abcba
hello     hellolleh
bonobo    bonobonob
radar     radar
hex       hexeh

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

code-golf  string  palindrome 
— अदनान
स्रोत
3
— जर्गर्ब
6
आपको यह निर्दिष्ट करना चाहिए कि उलटे हुए स्ट्रिंग को मूल स्ट्रिंग में दाईं ओर उलट दिया गया है। यदि यह बाईं ओर obonoboजा सकता है , तो परीक्षण मामले का एक बेहतर समाधान होगा।
— लेवल रिवर सेंट।
2
— Sp3000
2
@LevelRiverSt +1 सिर्फ इसलिए कि "ओबोनोबो" एक ऐसा अद्भुत शब्द है
— नथानिएल
1
@ नथानियल थैंक्स लेकिन bono b o nobएक पूरा वाकया है । भगवान और बोनो में क्या अंतर है? भगवान राउंड डबलिन भटकने का नाटक नहीं करते; बोनो; ;-)
— लेवल रिवर सेंट

जवाबों:

5

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

ṫỤfU$Ḣœ^;U

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

यह काम किस प्रकार करता है

ṫỤfU$Ḣœ^;U  Main link. Argument: s (string)

 Ụ          Yield all indices of s, sorted by their corr. character values.
ṫ           Tail; for each index n, remove all characters before thr nth.
            This yields the list of suffixes of s, sorted by their first character,
            then (in descending order) by length.
    $       Combine the two links to the left into a chain:
   U        Upend; reverse all suffixes.
  f         Filter; only keep suffixes that are also reversed suffixes.
            This gives the list of all palindromic suffixes. Since all of them
            start with the same letter, they are sorted by length.
     Ḣ      Head; select the first, longest palindromic suffix.
      œ^    Multiset symmetric difference; chop the selected suffix from s.
         U  Upend; yield s, reversed.
        ;   Concatenate the results to the left and to the right.
— डेनिस
स्रोत
15

पायथ (प्रतिबद्ध b93a874), 11 बाइट्स

.VkI_IJ+zbB

परीक्षण सूट

यह कोड Pyth के वर्तमान संस्करण में एक बग का शोषण करता है, जो b93a874 है । बग यह है कि _IJ+zbजैसे कि यह था q_J+zbJ+zb, जो इसके बराबर है _I+zb+zb, जब इसे चाहिए (पाइथ के डिजाइन इरादे से) पार्स किया जाता है q_J+zbJ, जो कि इसके बराबर है _I+zb। यह मुझे एक बाइट को बचाने की अनुमति देता है - बग तय होने के बाद, सही कोड होगा .VkI_IJ+zbJB। मैं इसके बजाय उस कोड की व्याख्या करूँगा।

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

.VkI_IJ+zbJB
                z = input()
.Vk             For b in possible strings ordered by length,
       +zb      Add z and b,
      J         Store it in J,
    _I          Check if the result is a palindrome,
   I            If so,
          J     Print J (This line doesn't actually exist, gets added by the bug.
          B     Break.
— isaacg
स्रोत
आप इस तरह के कोड के साथ कैसे आते हैं? यह बमुश्किल पठनीय है और बिल्कुल किसी के द्वारा समझने योग्य नहीं है जो पायथ से परिचित नहीं है। ऐसी भाषा का उद्देश्य क्या है।
— अनुकुल
5
@ ममो भाषा का उद्देश्य मनोरंजन के लिए लघु कोड लिखना है। यह एक मनोरंजक गतिविधि है। मैं इसे लिख सकता हूं क्योंकि मेरे पास बहुत अभ्यास है, और क्योंकि मैंने भाषा का आविष्कार किया है। मुझे पता है कि यह किसी ऐसे व्यक्ति के लिए समझ में नहीं आता है जो भाषा नहीं जानता है, यही कारण है कि मैंने स्पष्टीकरण को शामिल किया है।
— ईसैक
13

पायथन, 46 बाइट्स

f=lambda s:s*(s==s[::-1])or s[0]+f(s[1:])+s[0]

यदि स्ट्रिंग एक पैलिंड्रोम है, तो उसे वापस कर दें। अन्यथा, स्ट्रिंग के शेष के लिए पुनरावर्ती परिणाम के चारों ओर पहला अक्षर सैंडविच करें।

उदाहरण ब्रेकडाउन:

f(bonobo)
b  f(onobo) b
b o f(nobo) o b 
b o n f(obo) n o b
b o n obo n o b
— XNOR
स्रोत
मुझे लगता है कि आप एक बाइट को बचा सकते हैं यदि आप विपरीत स्थिति ( s!=s[::-1]) का उपयोग करते हैं
— एडिट्स
@aditsu जो काम करता है लेकिन एक बहु का उपयोग अभी तक कम है।
— xnor
9

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

f s|s==reverse s=s|h:t<-s=h:f t++[h]

अधिक आसानी से:

f s
 |s==reverse s = s
 |(h:t)<-s     = h:(f t)++[h]

यदि स्ट्रिंग एक पैलिंड्रोम है, तो उसे वापस कर दें। अन्यथा, स्ट्रिंग की पूंछ के लिए पुनरावर्ती परिणाम के आसपास पहला अक्षर सैंडविच।

इस मामले के लिए एक भराव का पालन sकरते h:tहुए, स्ट्रिंग को दूसरे गार्ड में विभाजित किया जाता है 1>0। यह s@(h:t)इनपुट के लिए करने से कम है ।

— XNOR
स्रोत
5

पायथ - 16 12 बाइट्स

4 बाइट्स ने @FryAmTheEggman को धन्यवाद दिया।

FGITW, बहुत गोल्फ संभव है।

h_I#+R_Q+k._

टेस्ट सूट ।

— Maltysen
स्रोत
5

ब्रेकीलॉग , 16 6 5 बाइट्स (गैर-प्रतिस्पर्धात्मक)

:Ac.r

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

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

व्याख्या

(?):Ac.        Output is the concatenation of Input with another unknown string A
      .r(.)    The reverse of the Output is the Output

बैकप्रॉपैगैशन इसे बनाता है ताकि इसके लिए पहला मान्य मूल्य Aसबसे कम होगा जिसे आप इसे एक तालमेल बनाने के लिए इनपुट के लिए संक्षिप्त कर सकते हैं।

वैकल्पिक समाधान, 5 बाइट्स

~@[.r

यह लगभग उपरोक्त उत्तर के समान है, सिवाय इसके कि "आउटपुट एक स्ट्रिंग के साथ इनपुट का संघटन है" के बजाय A, हम कहते हैं कि "आउटपुट एक स्ट्रिंग है जिसके लिए इनपुट आउटपुट का एक उपसर्ग है"।

— Fatalize
स्रोत
4

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

(s,a=[...s],r=a.reverse().join``)=>s.slice(0,a.findIndex((_,i)=>r.startsWith(s.slice(i))))+r

गणना और स्लाइस मूल स्ट्रिंग और इसके उलट के बीच ओवरलैप को दूर करते हैं।

— नील
स्रोत
4

रेटिना, 29 25

$
¶$_
O^#r`.\G
(.+)¶\1
$1

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

11 बाइट के लिए मार्टिन का बड़ा धन्यवाद !

यह केवल स्ट्रिंग की एक उलटी प्रतिलिपि बनाता है और उन्हें एक साथ चिकना करता है। इसका एकमात्र वास्तव में फैंसी हिस्सा उलटने की विधि है: O^#r`.\Gजो कि सॉर्ट मोड का उपयोग करके किया जाता है। हम दूसरे स्ट्रिंग के अक्षरों को सॉर्ट करते हैं (जो कि नई लाइनें नहीं हैं और स्ट्रिंग के अंत से लगातार हैं, धन्यवाद \G) उनके संख्यात्मक मान से, जो, चूंकि कोई संख्या नहीं है, 0. है। फिर हम रिवर्स करते हैं ^विकल्प के साथ इस स्थिर क्रम के परिणामों का क्रम । \Gमार्टिन से संबंधित फैंसी उपयोग के लिए सभी श्रेय :)

— FryAmTheEggman
स्रोत
3

CJam, 18

q__,,{1$>_W%=}#<W%

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

स्पष्टीकरण:

q         read the input
__        make 2 copies
,,        convert the last one to a range [0 … length-1]
{…}#      find the first index that satisfies the condition:
  1$>     copy the input string and take the suffix from that position
  _W%=    duplicate, reverse and compare (palindrome check)
<         take the prefix before the found index
W%        reverse that prefix
          at the end, the stack contains the input string and that reversed prefix
— aditsu
स्रोत
3

लुआ, 89 88 बाइट्स

मैंने जावास्क्रिप्ट को हरा दिया! \ o / सहेजे गए 1 बाइट @LeakyNun ^ ^ के लिए धन्यवाद

यह एक पूर्ण कार्यक्रम है, इसके इनपुट को कमांड-लाइन तर्क के रूप में लेता है।

i=1s=...r=s:reverse()while s:sub(i)~=r:sub(0,#r-i+1)do i=i+1 end print(s..r:sub(#r-i+2))

ungolfed

i=1                             -- initialise i at 1 as string are 1-indexed in lua
s=...                           -- use s as a shorthand for the first argument
r=s:reverse()                   -- reverse the string s and save it into r
while(s:sub(i)~=r:sub(0,#r-i+1))-- iterate while the last i characters of s
do                              -- aren't equals to the first i characters of r
  i=i+1                         -- increment the number of character to skip
end
print(s..r:sub(#r-i+2))         -- output the merged string
— Katenkyo
स्रोत
मेरा मानना ​​है कि पास के कोष्ठक whileको हटाया जा सकता है?
— लीक
@LeakyNun सुनिश्चित करें कि वे ^ ^
— कटेन्को
नहीं कर सकते i=i+1end?
— आउटगोल्फ जूल
1
@ E @Gʀɪᴋᴛʜᴇ अफसोस की बात है, मैं नहीं कर सकता। यह 1endहेक्साडेसिमल संख्या के रूप में मूल्यांकन करने का प्रयास करेगा । आमतौर पर, आप [abcdef]एक संख्या के बिना सीधे उपयोग नहीं कर सकते हैं क्योंकि इसे एक हेक्साडेसिमल माना जाता है। एक और अपवाद है 0x।
— काटेन्को जू
3

प्रोलॉग, 43 बाइट्स

a(S):-append(S,_,U),reverse(U,U),writef(U).

यह इनपुट के रूप में एक कोड स्ट्रिंग की उम्मीद करता है, जैसे SWI-Prolog 7: a(`hello`).

व्याख्या

यह मूल रूप से मेरे Brachylog उत्तर का एक बंदरगाह है।

a(S) :-               % S is the input string as a list of codes
    append(S,_,U),    % U is a list of codes resulting in appending an unknown list to S
    reverse(U,U),     % The reverse of U is U
    writef(U).        % Write U to STDOUT as a list of codes
— Fatalize
स्रोत
3

ऑक्टेव, 78 75 बाइट्स

सहेजे गए 3 बाइट्स Eᴛʜᴇ 3 Ged के लिए धन्यवाद!

function p=L(s)d=0;while~all(diag(s==rot90(s),d++))p=[s fliplr(s(1:d))];end

आइडोन अभी भी नामित कार्यों के लिए विफल रहता है, लेकिन यहां एक कार्यक्रम के रूप में कोड का एक परीक्षण रन है।

— बीकर
स्रोत
2

पर्ल, 37 बाइट्स

Xnor के उत्तर के आधार पर।

के लिए +2 शामिल है -lp

एसटीडीआईएन पर इनपुट के साथ चलाएं, जैसे

palindromize.pl <<< bonobo

palindromize.pl:

#!/usr/bin/perl -lp
s/.//,do$0,$_=$&.$_.$&if$_!~reverse
— टन हास्पेल
स्रोत
1

जे, 20 बाइट्स

,[|.@{.~(-:|.)\.i.1:

यह एक राक्षसी क्रिया है। इसे यहाँ आज़माएँ। उपयोग:

   f =: ,[|.@{.~(-:|.)\.i.1:
   f 'race'
'racecar'

व्याख्या

मैं इस तथ्य का उपयोग कर रहा हूं कि एस का पैलिंड्रोमाइजेशन एस + रिवर्स (पी) है , जहां पी एस का सबसे छोटा उपसर्ग है जिसके निष्कासन के परिणामस्वरूप पैलिंड्रोम होता है। जे में, एक एरे के पहले तत्व की खोज करना थोड़ा क्लिंक है जो एक विधेय को संतुष्ट करता है; इसलिए अनुक्रमण।

,[|.@{.~(-:|.)\.i.1:  Input is S.
        (    )\.      Map over suffixes of S:
         -:             Does it match
           |.           its reversal? This gives 1 for palindromic suffixes and 0 for others.
                i.1:  Take the first (0-based) index of 1 in that array.
 [   {.~              Take a prefix of S of that length: this is P.
  |.@                 Reverse of P.
,                     Concatenate it to S.
— Zgarb
स्रोत
1

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

import Data.List
f i=[i++r x|x<-inits i,i++r x==x++r i]!!0
r=reverse

प्रयोग उदाहरण: f "abcb"-> "abcba"।

initsइनपुट के माध्यम से खोजें i(जैसे inits "abcb"-> ["", "a", "ab", "abc", "abcb"]) जब तक आप एक ऐसा नहीं पाते हैं जहां यह उल्टा iहै, एक पैलिंड्रोम बनाने के लिए।

— nimi
स्रोत
r=reverseपहले नहीं जाना है f i=...?
— आउटगोल्फ जूल
@ E @G।: नहीं, आप किसी भी आदेश का उपयोग कर सकते हैं।
— नीम जूल
मैं 46 बाइट्स में कामयाब रहा। मुझे यकीन है कि यह और भी बेहतर किया जा सकता है।
— Theonlygusti
@theonlygusti: xnor का उत्तर देखें ।
— निमि
1

MATL , 17 16 बाइट्स

@ Aditsu के CJam जवाब में पूरी तरह से प्रेरित ।

`xGt@q:)PhttP=A~

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

व्याख्या

`        % Do...while loop
  x      %   Delete top of stack, which contains a not useful result from the
         %   iteration. Takes input implicitly on first iteration, and deletes it
  G      %   Push input
  t      %   Duplicate
  @q:    %   Generate range [1,...,n-1], where n is iteration index. On the  first
         %   iteration this is an empty array
  )      %   Use that as index into copy of input string: get its first n elements
  Ph     %   Flip and concatenate to input string
  t      %   Duplicate. This will be the final result, or will be deleted at the
         %   beginning of next iteration
  tP     %   Duplicate and flip
  =A~    %   Compare element-wise. Is there some element different? If so, the
         %   result is true. This is the loop condition, so go there will be a 
         %   new iteration. Else the loop is exited with the stack containing
         %   the contatenated string
         % End loop implicitly
         % Display stack contents implicitly
— लुइस मेंडो
स्रोत
1

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

यह उत्तर xnor के पायथन और हास्केल समाधानों पर आधारित है ।

f=->s{s.reverse==s ?s:s[0]+f[s[1..-1]]+s[0]}
— Sherlock9
स्रोत
नहीं कर सकते ==s?s:?
— आउटगोल्फ जूल
@ E @G try irb एक फिट फेंकता है अगर मैं इसे आज़माता हूँ। रूबी 1.9 के बाद से उपयोग किए जाने वाले टर्नरी और प्रतिस्थापन के ?बीच यह कैसे करना है, इसके साथ कुछ होना चाहिए?:?x == 'x'
— शर्लक
1

ओरेकल SQL 11.2, 195 बाइट्स

SELECT MIN(p)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(p))FROM(SELECT:1||SUBSTR(REVERSE(:1),LEVEL+1)p FROM DUAL WHERE SUBSTR(:1,-LEVEL,LEVEL)=SUBSTR(REVERSE(:1),1,LEVEL)CONNECT BY LEVEL<=LENGTH(:1));

संयुक्त राष्ट्र के golfed

SELECT MIN(p)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(p))
FROM (
       SELECT :1||SUBSTR(REVERSE(:1),LEVEL+1)p 
       FROM   DUAL 
       WHERE  SUBSTR(:1,-LEVEL,LEVEL)=SUBSTR(REVERSE(:1),1,LEVEL)
       CONNECT BY LEVEL<=LENGTH(:1)
     );
— Jeto
स्रोत
1

गंभीरता से, 34 बाइट्स

╩╜lur`╜╨"Σ╜+;;R=*"£M`MΣ;░p╜;;R=I.

अंतिम चरित्र एक गैर-ब्रेकिंग स्पेस (ASCII 127 या 0x7F) है।

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

स्पष्टीकरण:

╩╜lur`╜╨"Σ╜+;;R=*"£M`MΣ;░p╜;;R=I.<NBSP>
╩                                        push inputs to registers (call the value in register 0 "s" for this explanation)
 ╜lur                                    push range(0, len(s)+1)
     `              `M                   map (for i in a):
      ╜╨                                   push all i-length permutations of s
        "        "£M                       map (for k in perms):
         Σ╜+                                 push s+''.join(k) (call it p)
            ;;R=                             palindrome test
                *                            multiply (push p if palindrome else '')
                      Σ                  summation (flatten lists into list of strings)
                       ;░                filter truthy values
                         p               pop first element (guaranteed to be shortest, call it x)
                          ╜;;R=I         pop x, push s if s is palindromic else x
                                .<NBSP>  print and quit
— मेगो
स्रोत
1

सी #, 202 बाइट्स

मैंने कोशिश की।

class P{static void Main(string[]a){string s=Console.ReadLine(),o=new string(s.Reverse().ToArray()),w=s;for(int i=0;w!=new string(w.Reverse().ToArray());){w=s.Substring(0,i++)+o;}Console.WriteLine(w);}}

Ungolfed:

class P
{
    static void Main(string[] a)
    {
        string s = Console.ReadLine(), o = new string(s.Reverse().ToArray()), w = s;
        for(int i = 0; w!=new string(w.Reverse().ToArray());)
        {
            w = s.Substring(0, i++) + o;
        }
        Console.WriteLine(w);
        Console.ReadKey();
    }

}

क्या कोई मुझे किसी भी विचार के साथ दो कॉल करने के लिए प्रदान कर सकता है। रिवर्स ()। ToArray ()? एक अलग विधि अधिक बाइट्स है।

— SkyPharaoh
स्रोत
0

QBIC , 41 बाइट्स

;_FA|C=A{a=a+1~C=_fC||_XC\C=A+right$(B,a)

स्पष्टीकरण:

;_FA|    Read A$ from the cmd line, then flip it to create B$
C=A      Set C$ to be A$
{        Start an infinite DO-loop
a=a+1    Increment a (not to be confused with A$...)
~C=_fC|  If C$ is equal to its own reversed version
|_XC     THEN end, printing C$
\C=A+    ELSE, C$ is reset to the base A$, with
right$(B the right part of its own reversal
,a)      for length a (remember, we increment this each iteration
         DO and IF implicitly closed at EOF
— steenbergh
स्रोत
0

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

f l|l==reverse l=l|(h:t)<-l=l!!0:(f$tail l)++[l!!0]

अगर वहाँ कोष्ठक हटाने के लिए एक रास्ता है मैं सोच रहा हूँ (f$tail l)++[l!!0] ...

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