सभी अनाग्राम, और सबानग्राम को भी खोजें!

Question

यह सवाल भारी ही आधारित होता इस सवाल का , लेकिन अतिरिक्त कठिनाइयों के एक नंबर पैदा करना चाहिए।

आपका कार्य

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

इनपुट

आप किसी स्ट्रिंग को स्वीकार कर सकते हैं, जो किसी भी मानक इनपुट विधि द्वारा किसी भी लंबाई> 0 का हो सकता है। इसमें कोई भी ASCII वर्ण हो सकते हैं।

उत्पादन

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

अन्य नियम

स्टैंडर्ड लूपहोल्स को बंद कर दिया गया है

स्कोरिंग

यह कोड-गोल्फ है , कम से कम बाइट्स जीतता है।

Comments

क्या रिक्त स्ट्रिंग एक संभावित विपर्यय है?

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

मूल स्ट्रिंग / sustrings की अनुमति है?

— कैलक्यूलेटरफ्लीन

@CalculatorFeline "आपको एक ही स्ट्रिंग को दो बार आउटपुट नहीं करना चाहिए, या इनपुट के बराबर स्ट्रिंग का उत्पादन करना चाहिए।"

— जोनाथन एलन

@DigitalTrauma, "आप एक स्ट्रिंग स्वीकार कर सकते हैं, जो किसी भी मानक इनपुट विधि द्वारा किसी भी लम्बाई> 0 का हो सकता है "। (जोर दिया गया)

— ग्रिएफॉन

कुछ टेस्ट केस मददगार होंगे

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

Answer 1

05AB1E , 7 बाइट्स

Œ€œ˜Ù¹K

एक फ़ंक्शन जो इनपुट से एक स्ट्रिंग को स्वीकार करता है और स्टैक पर स्ट्रिंग की एक सूची छोड़ देता है। एक पूर्ण कार्यक्रम के रूप में सूची का एक प्रतिनिधित्व मुद्रित किया जाता है।

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

कैसे?

        - push input
Π      - all substrings
 €œ     - for €ach: all permutations
   ˜    - flatten
    Ù   - de-duplicate
     ¹  - push 1st input onto top of stack
      K - pop a,b; push a without any b's (remove the copy of the input from the list)
        - as a full program: implicit print of the top of the stack

Comments

और ... आपने कुछ कम भी प्रबंधित किया।

— ग्रिफन

यह एक ही एल्गोरिथ्म है, बस कम बाइट्स।

— जोनाथन एलन

हां, भाषा परिवर्तन सब कुछ था, लेकिन अभी भी प्रभावशाली है।

— ग्रिफन

@ ais523 ऐसा लग रहा है कि मुझे दोनों गलत रास्ते मिल गए हैं!

— जोनाथन एलन

@ ais523 मुझे लगता है कि यह तय है।

— जोनाथन एलन

Answer 2

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

{sp}ᶠdb

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

व्याख्या

{sp}ᶠdb
{  }ᶠ    Find all
  p        permutations of
 s         a substring of {the input}
     d   Remove duplicates (leaving the list otherwise in the same order)
      b  Remove the first (the input itself)

Comments

(2) का क्या अर्थ है?

— ग्रिएफॉन

@Gryphon (afaik) ब्रांचलॉग के 2 संस्करण हैं, यह V2 का उपयोग कर रहा है।

— जॉन हैमिल्टन

ठीक है, निश्चित नहीं था कि यह संस्करण संख्या या एक अलग, और संभवतः अवैध तरीके का उपयोग करके बाइट गिनती थी।

— ग्रिएफॉन

यह दूसरी बार है जब मुझे पूछा गया है। मुझे लगता है कि मुझे इसे लिखना शुरू करना होगा (v2)।

Answer 3

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

ẆŒ!€;/QḟW

एक मोनडिक लिंक एक सूची को स्वीकार करता है और इनपुट को छोड़कर सभी अलग-अलग उप-आरेखों की सूची वापस करता है।

इसे ऑनलाइन आज़माएं! (फुटर ने नई सूची के साथ जुड़कर परिणामी सूची छापी।)

कैसे?

ẆŒ!€;/QḟW - Link: list of characters, s
Ẇ         - all contiguous sublists of s
 Œ!€      - all permutations for €ach sublist now a list of lists of lists)
     /    - reduce by:
    ;     -   concatenation (flattens the list by one level)
      Q   - de-duplicate (gets the unique entries)
        W - wrap s in a list (otherwise filtering will attempt to remove characters)
       ḟ  - filter discard from left if in right (remove the one equal to the input)

Answer 4

अजगर, १२

-{.n.pM.:Q)]

ऑनलाइन टेस्ट ।

         Q       # input
       .: )      # all substrings
    .pM          # all permutations of all substrings
  .n             # flatten
 {               # deduplicate
-          ]Q    # subtract (list of) (implicit) input

Comments

@ ais523 रेडोन - मुझे लगता है कि यह अभी सही है।

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

Answer 5

जाप , 10 बाइट्स

à má c â Å

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

मैं उपयोग करने के लिए मिल गया है à, áऔर âभी एक ही जवाब में सभी के क्रम में। क्या संयोग है...

व्याख्या

 à má c â Å
Uà má c â s1  // Ungolfed
              // Implicit: U = input string
Uà            // Take all combinations of characters in the input string.
   má         // Map each combination to all of its permutations.
      c       // Flatten into a single array.
        â     // Uniquify; remove all duplicates.
          s1  // Remove the first item (the input) from the resulting array.
              // Implicit: output resulting array, separated by commas

Comments

आपने Å को भी प्रबंधित किया।

— ग्रिफन

Answer 6

गणितज्ञ, 60 बाइट्स

DeleteCases[""<>#&/@Permutations[c=Characters@#,Tr[1^c]],#]&

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

Answer 7

जावा 8, 313 312 306 बाइट्स

import java.util.*;s->{Set l=new HashSet();for(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),l));l.remove(s);l.forEach(System.out::println);}void p(String p,String s,Set l){int n=s.length(),i=0;if(n<1)l.add(p);else for(;i<n;p(p+s.charAt(i),s.substring(0,i)+s.substring(i+++1,n),l));}

यहाँ मेरे उत्तर का संशोधित संस्करण , जहाँ p("",s,l);से बदल दिया गया हैfor(int z=s.length(),i=0,j;i<z;i++)for(j=i;j<z;p("",s.substring(i,j+++1),l));

-6 बाइट्स मेरे जुड़े हुए जवाब में @ OlivierGrégoire को धन्यवाद ।

इस भाग की व्याख्या:

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

for(int l=s.length(),i=0,j;i<l;i++)
                               // Loop (1) from 0 to the length of the String (exclusive)
  for(j=i+1;j<=l;              //  Loop (2) from 1 to the length of the String (exclusive)
    p("",                      //   Call the permutation-method,
    s.substring(i,j+++1),l));  //   with a substring from `i` to `j` (inclusive)
                               //  End of loop (2) (implicit / single-line body)
                               // End of loop (1) (implicit / single-line body)

Answer 8

पर्ल 6 , 75 बाइट्स

{unique(flat $_,.comb.combinations.skip».permutations.map(*».join)).skip}

कोशिश करो

विस्तारित:

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

  unique(            # return each (sub)anagram once

    flat             # unstructure the following (List of Lists into flat List)
      $_,            # the input (so we can skip it at the end)

      .comb          # split the input into graphemes
      .combinations  # get all the combinations
      .skip\         # skip the first empty combination
      ».permutations # get all the permutations of each combination
      .map(*».join)  # join the inner permutations

  ).skip             # skip the first value (the input)
}