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

Question

17 सवालों के होने में चिह्नित बावजूद विपर्यय , हम अभी भी इस सवाल इसलिए यहाँ यह है नहीं है,।

आपका कार्य

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

इनपुट

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

उत्पादन

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

अन्य नियम

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

स्कोरिंग

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

Comments

क्या हम सामान्य "प्रोग्राम या फंक्शन" मानक का पालन करते हैं?

— जोनाथन एलन

@JonathanAllan मुझे लगता है कि अगर इसका स्पष्ट रूप से उल्लेख नहीं किया गया है, तो आप एक कार्यक्रम या एक समारोह प्रस्तुत कर सकते हैं। मैंने आम तौर पर अपने प्रश्नों में निहित है कि कोई समस्या नहीं है

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

हां, निश्चित रूप से या तो एक कार्यक्रम या एक समारोह ठीक काम करेगा।

— ग्रिफन

निकटता से संबंधित

— FryAmTheEggman

@gryphon आप कैसे चीजों को संपादित कर रहे हैं

— लोमड़ी

Answer 1

05AB1E , 3 बाइट्स

œÙ¦

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

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

कैसे?

    - push input
œ   - pop and push a list of all permutations (input appears at the head)
 Ù  - pop and push a list of unique items (sorted by first appearance)
  ¦ - pop and push a dequeued list (removes the occurrence of the input)
    - As a full program: implicit print of the top of the stack

Comments

अनुमान लगाया जाना चाहिए कि 05AB1E अत्यधिक कम होगा।

— ग्रिफन

Answer 2

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

->x{(x.chars.permutation.map(&:join)-[x])|[]}

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

बिल्ट-इन होने के बावजूद, "क्रमचय" शब्द वास्तव में लंबा है :(

Comments

|[]अनावश्यक लगता है?

— १

@ सेथ्रिन, काफी नहीं। युक्ति कहती है कि डुप्लिकेट को हटा दिया जाना चाहिए। |[]से छोटा है .uniq।

— यम्बर्ट

Answer 3

MATL , 7 बाइट्स

tY@1&X~

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

व्याख्या

t     % Implicitly input a string, say of length n. Duplicate
Y@    % All permutations. May contain duplicates. Gives a 2D char array of 
      % size n!×n with each permutation in a row
1&X~  % Set symmetric difference, row-wise. Automatically removes duplicates.
      % This takes the n!×n char array and the input string (1×n char array)
      % and produces an m×n char array containing the rows that are present 
      % in exactly one of the two arrays
      % Implicitly display

Answer 4

अजगर , 4 ४

-{.p

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

  .pQ     # all permutations of the (implicit) input string
 {        # de-duplicate
-    Q    # subtract (implicit) input

Comments

महान गोल्फ नौकरी। बहुत प्रभावशाली 05AB1E उत्तर बांधने पर बधाई।

— ग्रिफॉन

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

— ग्रिएफॉन

इसे ठीक करने के लिए धन्यवाद। हालांकि इसके बारे में बहुत बुरा है कि आप अपनी बाइट को गिन रहे हैं।

— ग्रिफन

मैं एक ही जवाब के साथ आया था, लेकिन डुप्लिकेट करना भी भूल गया। बड़े मन वाले ऐसा सोचते हैं?

— टॉर्नेडो 547

Answer 5

जाप , 6 बाइट्स

á â kU

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

व्याख्या

 á â kU
Uá â kU   // Ungolfed
          // Implicit: U = input string
Uá        // Take all permutations of U.
   â      // Remove duplicates.
     kU   // Remove U itself from the result.
          // Implicit: output resulting array, separated by commas

Comments

जीत चुराने के लिए बधाई। +1

— ग्रिफन

@Gryphon इतनी जल्दी नहीं, मैं चौंक जाऊँगा अगर यह 05AB1E में 3 बाइट्स नहीं है ...

— ETHproductions

मैं अब के लिए मतलब था। यह ऐसा नहीं है जैसे मैं आपको अभी तक स्वीकार कर रहा हूं।

— ग्रिएफॉन

अगर @ डेनिस जेली में ऐसा करता है, तो यह शायद 2 बाइट्स की तरह होगा। एक बस डेनिस को पछाड़ता नहीं है।

— ग्रिएफॉन

3 बाइट की भविष्यवाणी अच्छी थी, लेकिन क्या एक 2 है !

— जोनाथन एलन

Answer 6

हास्केल, 48 40 बाइट्स

import Data.List
a=tail.nub.permutations

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

लियो की tailटिप के लिए धन्यवाद 8 बाइट्स सहेजे गए ।

Comments

आप tailइसके बजाय उपयोग कर सकते हैं delete x, क्योंकि मूल स्ट्रिंग हमेशा क्रमपरिवर्तन की सूची में पहले स्थान पर आ जाएगी। यह आपको एक बिंदु-मुक्त समाधान पर स्विच करने देगा, और फिर एक अनाम फ़ंक्शन पर, बहुत सारे बाइट्स सहेजे जाएंगे!

— सिंह

@ ग्रेट, धन्यवाद!

— क्रिस्टियन लुपस्कू

Answer 7

CJam , 8 बाइट्स

l_e!\a-p

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

व्याख्या

l    e# Read string from input
_    e# Duplicate
e!   e# Unique permutations. Gives a list of strings
\    e# Swap
a    e# Wrap in a singleton array
-    e# Set difference. This removes the input string
p    e# Pretty print the list

Comments

@JonathanAllan धन्यवाद, ठीक किया गया

— लुइस मेंडो

@Gryphon खैर, जोनाथन के बहुत ही उपयुक्त सुधार के बाद 7;;

— लुइस मेंडो

मैंने अब उस प्रश्न का उत्तर दे दिया है।

— ग्रिफन

उम्म, टीआईओ अभी भी मेरे लिए मूल स्ट्रिंग का उत्पादन कर रहा है?

— ग्रिफन

@Gryphon क्षमा करें, यह अब काम करना चाहिए। मैं स्पष्ट रूप से इसके लिए बहुत थक गया हूं; बिस्तर पर जा रहे हैं :-P

— लुइस मेंडो

Answer 8

मैथेमेटिका, 47 बाइट्स

Drop[StringJoin/@Permutations[Characters@#],1]&

Comments

मैं इनमें से एक की प्रतीक्षा कर रहा था, लेकिन मुझे पूरा यकीन था कि यह जीतने वाला नहीं था। Kinda आश्चर्य है कि वहाँ सिर्फ एक में निर्मित नहीं है।

— Gryphon

StringJoin/@Rest@Permutations@Characters@#&43 बाइट्स है।

— जेसी

Answer 9

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

Œ!QḊ

पात्रों की एक सूची लेने और पात्रों की सूची की सूची को लौटाने वाला एक विचित्र लिंक - सभी अलग-अलग आरेख जो इनपुट के बराबर नहीं हैं।

इसे ऑनलाइन आज़माएं! (पाद लेख एक प्रोग्राम बनाता है जो सूची में शामिल हो जाता है, अन्यथा सुर्खियों से बचने के लिए नई सूची और प्रिंट से जुड़ता है)।

कैसे?

Œ!QḊ - Link: list of characters     e.g. "text"
Œ!   - all permutations of the list      ["text","tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","extt","ettx","etxt","xtet","xtte","xett","xett","xtte","xtet","ttex","ttxe","tetx","text","txte","txet"]
  Q  - de-duplicate                      ["text","tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","xtet","xtte","xett"]
   Ḋ - dequeue (the first one = input)          ["tetx","txet","txte","ttex","ttxe","etxt","ettx","extt","xtet","xtte","xett"]

Comments

प्रभावशाली। क्या कोई स्पष्टीकरण होगा, क्योंकि मैं जेली नहीं हूं?

— ग्रिफन

हां बिल्कुल!

— जोनाथन एलन

मैंने इसे युगों पहले ही ले लिया था, इसलिए मुझे हेडर में पाठ ("?") मिला था और Yयदि कार्यों को अनुमति दी गई थी तो हटाने के बारे में ... मैं देख रहा हूं कि आपने इस प्रश्न पर अपने संपादन को उलट दिया: /

— जोनाथन एलन

Answer 10

पायथन 3, 85 76 63 बाइट्स

एक समारोह के रूप में, और पात्रों की सूची के रूप में तार लौटते हैं (मुझे बताने की अनुमति के लिए @ pizzapants184 के लिए धन्यवाद):

from itertools import*
lambda z:set(permutations(z))-{tuple(z)}

एक समारोह के रूप में:

from itertools import*
lambda z:map("".join,set(permutations(z))-{tuple(z)})

एक पूर्ण कार्यक्रम के रूप में 85 बाइट्स:

from itertools import*
z=input()
print(*map("".join,set(permutations(z))-{tuple(z)}))

अगर ('ए', 'बी', 'सी') स्ट्रिंग को आउटपुट करने की अनुमति दी जाती है तो थोड़ा कम किया जा सकता है (मुझे यकीन नहीं है कि यह है)।

Comments

यदि केवल अजगर एक गोल्फ भाषा था, एह।

— ग्रिएफॉन

('ए', 'बी', 'सी') के रूप में आउटपुट ठीक होना चाहिए, यह pyth उत्तर करता है (मूल रूप से)।

— pizzapants184

Answer 11

जावा 8, 245 239 237 बाइट्स

import java.util.*;s->{Set l=new HashSet();p("",s,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,n),l));}

-6 बाइट्स @ OlivierGrégoire को धन्यवाद ।

विशिष्ट वर्बोज़ जावा .. मुझे बहुत सारे <10 बाइट उत्तर मिलते हैं, और यहाँ मैं 200+ बाइट्स के साथ हूँ .. XD

स्पष्टीकरण:

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

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

s->{                        // Method (1) with String parameter and no return-type
  Set l=new HashSet();      //  Set to save all permutations in (without duplicates)
  p("",s);                  //  Determine all permutations, and save them in the Set
  l.remove(s);              //  Remove the input from the Set
  l.forEach(                //  Loop over the Set
    System.out::println);   //   And print all the items
}                           // End of method (1)

// This method will determine all permutations, and save them in the Set:
void p(String p,String s,Set l){
  int n=s.length(),         //  Length of the first input String
      i=0;                  //  And a temp index-integer
  if(n<1)                   //  If the length is 0:
    l.add(p);               //   Add the permutation input-String to the Set
  else                      //  Else:
    for(;i<n;               //   Loop over the first input-String
      p(                    //    And do a recursive-call with:
        p+s.charAt(i),      //     Permutation + char
        s.substring(0,i)+s.substring(++i,n),l)
                            //     Everything except this char
      );                    //   End of loop
}                           // End of method (2)

Comments

l.forEach(System.out::println);अपने मुद्रण लूप के बजाय का उपयोग करें । इसके अलावा, मुझे लगता है कि इसके Setस्तर के बिना वर्ग स्तर पर परिभाषित किया जाना पसंद नहीं है , एक लंबो परिभाषित ने कहा कि कोई नहीं जानता कि एक विधि और कहां है। यह सिर्फ मेरे लिए बहुत ज्यादा है। मैं समझ सकता हूं कि आयात को बाकी हिस्सों से अलग किया जा रहा है, लेकिन वहां कुछ भी निहित नहीं है, यह कुछ और के साथ स्निपेट्स के संग्रह की तरह दिखता है। मुझे क्षमा करें, लेकिन पहली बार पीसीजी में, मैं -1 :( देता हूं

— ओलिवियर ग्रेजायर

@ OlivierGrégoire के लिए टिप के लिए सबसे पहले धन्यवाद forEach। वर्ग-स्तर के लिए Set, विकल्प क्या है? मुख्य-विधि सहित पूरे वर्ग को पोस्ट करें? मुख्य-पद्धति को छोड़कर पूरी कक्षा को पोस्ट करें, लेकिन कक्षा ही, इंटरफ़ेस और फ़ंक्शन नाम सहित?

— केविन क्रूज़सेन

मैं पूरी क्लास लिखूंगा। वह सबसे छोटा आत्म-निहित है जिसे मैं पा सकता हूं। को जोड़ने की आवश्यकता नहीं है public static void main, बस "प्रविष्टि विधि है ..."। बात यह है कि वर्तमान में आपका उत्तर सभी "स्व-निहित" नियमों को तोड़ता है। मैं नियमों को तोड़ने के खिलाफ नहीं हूं, लेकिन टूट रहा हूं? हाँ, मुझे लगता है :(

— ओलिवियर ग्रेजायर

एक और विचार: पैरामीटर के रूप में सेट पास करें? हेल्पर फंक्शन, मैं पूरी तरह से समझ सकता हूं, लेकिन यह हर चीज के बाहर सेट को परिभाषित कर रहा है जो मुझे टिक करता है।

— ओलिवियर ग्रेगोइरे

@ ओलिवियरग्रेयर ओके, आपके दूसरे सुझाव के लिए गया था। वास्तव में अधिक समझ में आता है, इसलिए मैं अभी से इसका उपयोग करूंगा। ईमानदार प्रतिक्रिया के लिए धन्यवाद।

— केविन क्रूज़सेन

Answer 12

पर्ल 6 ,  39  38 बाइट्स

*.comb.permutations».join.unique[1..*]

कोशिश करो

*.comb.permutations».join.unique.skip

कोशिश करो

विस्तारित

*               # WhateverCode lambda (this is the parameter)
.comb           # split into graphemes
.permutations\  # get all of the permutations
».join          # join each of them with a hyper method call
.unique         # make sure they are unique
.skip           # start after the first value (the input)

Answer 13

सी ++, 142 बाइट्स

#include<algorithm>
void p(std::string s){auto b=s;sort(begin(s),end(s));do if(s!=b)puts(s.data());while(next_permutation(begin(s),end(s)));}

ungolfed

#include <algorithm>

void p(std::string s)
{
    auto b = s;                    // use auto to avoid std::string
    sort(begin(s), end(s));        // start at first permutation
    do
      if (s != b)                  // only print permutation different than given string
        puts(s.data());
    while (next_permutation(begin(s), end(s))); // move to next permutation
}

Answer 14

के (ओके) , 13 बाइट्स

समाधान:

1_?x@prm@!#x:

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

स्पष्टीकरण:

मूल्यांकन दाएं-बाएं किया जाता है।

1_?x@prm@!#x: / the solution
           x: / store input in variable x
          #   / count length of x, #"abc" => 3
         !    / range, !3 => 0 1 2
     prm@     / apply (@) function permutations (prm) to range
   x@         / apply (@) these pumuted indixes back to original input
  ?           / return distinct values
1_            / drop the first one (ie the original input)

Answer 15

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

मेरे अतीत के उत्तर से अपनाया गया ।

S=>(R=new Set,p=(s,m='')=>s[0]?s.map((_,i)=>p(a=[...s],m+a.splice(i,1))):R.add(m),_=p([...S]),[...R])

f=
S=>(R=new Set,p=(s,m='')=>s[0]?s.map((_,i)=>p(a=[...s],m+a.splice(i,1))):R.add(m),_=p([...S]),[...R])


console.log(
  f('ABC'),
  f('ABCD'),
  f('ABCC'),
  f('AABBC')
)

Answer 16

पर्ल 5 , 89 + 2 ( -F) = 91 बाइट्स

$,=$_;$"=",";map{say if!$k{$_}++&&$,ne$_&&(join"",sort@F)eq join"",sort/./g}glob"{@F}"x@F

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

Comments

आप एक स्पष्टीकरण जोड़ना चाह सकते हैं।

— Gryphon