वर्णानुक्रम में एक स्ट्रिंग की अनुमति दें

Question

कार्य

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

उदाहरण:

इनपुट: buzz

आउटपुट:

buzz
bzuz
bzzu
ubzz
uzbz
uzzb
zbuz
zbzu
zubz
zuzb
zzbu
zzub

नियम

• यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।
• प्रत्येक / किसी भी लाइन पर ट्रेलिंग स्पेस ठीक हैं
• अंतिम पंक्ति की अनुमति के बाद एक एकल नई लाइन (लेकिन अब और नहीं)

Comments

क्या आउटपुट स्वरूप हो सकता है ["buzz" "bzuz" "bzzu" "ubzz" "uzbz" "uzzb" "zbuz" "zbzu" "zubz" "zuzb" "zzbu" "zzub"]?

— लुइस मेंडो

क्षमा करें, जैसा कि मैंने उल्लेख किया है, मैं नकचढ़ा हूं;) आउटपुट अलग-अलग लाइनों पर होना चाहिए, बजाय एक सूची प्रारूप के

— ब्रायन ग्रैडिन

हाँ, यह समझ में आता है। मैं सिर्फ यह देखना चाहता था कि क्या मैं अपने सीजाम के उत्तर ( N*से p) :-)

— लुइस

एक ठोस पहली चुनौती!

— xnor

इतने सारे निर्माण!

— डैन

Answer 1

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

ṢŒ!QY

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

व्याख्या

Ṣ         Sort
 Œ!       All permutations
   Q      Unique
    Y     Join by linefeeds

Comments

और ... हमारे पास 100000 पोस्ट हैं! बधाई!

— ETHproductions

@ETHproductions हेह! धन्यवाद! :-)

— लुइस मेंडू

मेरी तरफ से भी बधाई हो :) @ETHproductions आपको उस परिणाम के लिए कैसे मिला? मैं बस उत्सुक हूँ ...

— geisterfurz007 11:16 पर इस अराजकता

@ geisterfurz007 पोस्ट के निचले भाग में "शेयर" लिंक पर क्लिक करें। URL में पोस्ट की ID है।

— मार्टिन एंडर

ओह, तो यह ppcg की 100000 वीं पोस्ट है! मुझे लगा कि लुइस मेंडो पहले से ही उस नंबर पर था। मेरी गलती। स्पष्टीकरण के लिए धन्यवाद!

— geisterfurz007 इस अराजकता को

Answer 2

05AB1E ,  4  3 बाइट्स

अपडेट किया गया, œपुराने संस्करण को तोड़ने के अपडेट के बाद ,
जिसने मैजिक ऑक्टोपस यूरन द्वारा सुझाए गए बाइट को भी बचा लिया ।

œê»

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

व्याख्या

œ     # get all permutations of input
 ê    # sort and remove duplicates
  »   # join list by newlines

Comments

œê»गैर-विरासत के लिए ठीक है।

— मैजिक ऑक्टोपस

@MagicOctopusUrn: यह वास्तव में दोनों संस्करणों के लिए आवश्यक है क्योंकि œअब दोनों में स्ट्रिंग की सूची देता है।

— एमिगा

Answer 3

MATL , 4 बाइट्स

Y@Xu

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

व्याख्या

Y@    % Implicit input. Push 2D array of all permutations, each on a row, sorted
Xu    % Unique rows. Implicitly display

Answer 4

पायथन 3.5, 79 बाइट्स

def f(s,w=''):
 s or print(w)
 for c in sorted({*s}):t=s*1;t.remove(c);f(t,w+c)

एक फ़ंक्शन जो मुद्रण द्वारा वर्णों और आउटपुट की सूची के रूप में इनपुट लेता है।

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

Comments

एक तार की सूची में ले लो, एक स्ट्रिंग नहीं।

— xnor

Answer 5

सीजाम , 5 बाइट्स

एक सुधार के लिए @EriktheOutgolfer के qबजाय ( इसके बजाय r)

qe!N*

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

व्याख्या

q        e# Read input as a string
 e!      e# Unique permutations, sorted
   N*    e# Join by newline. Implicitly display

Answer 6

पायथ - 5 बाइट्स

jS{.p

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

j        Join. Implictly joins on newlines.
 S       Sort
  {      Uniquify
   .p    All permutations, implicitly run on input.

Comments

क्या Sवाकई जरूरत है?

— लुइस मेंडू

@LuisMendo यदि इनपुट पहले से सॉर्ट नहीं किया गया है, तो इसकी आवश्यकता है।

— isaacg

@isaacg धन्यवाद! मुझे बस एहसास हुआ कि मुझे अपने जेली उत्तर के साथ

— लुइस मेंडो

@LuisMendo किसके पास है।

— मैलेनसेन

Answer 7

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

import Data.List;unlines.sort.nub.permutations

2 बाइट्स नेमी को धन्यवाद दिया

Comments

आपको फ़ंक्शन के लिए नाम की आवश्यकता नहीं है, इसलिए आप ड्रॉप कर सकते हैं f=।

— निमि

Answer 8

जे, 19 बाइट्स

/:~@~.@:{~!@#A.&i.#

परीक्षण का मामला

   f =: /:~@~.@:{~!@#A.&i.#
   f 'buzz'
buzz
bzuz
bzzu
ubzz
uzbz
uzzb
zbuz
zbzu
zubz
zuzb
zzbu
zzub

व्याख्या

यह एक 4-ट्रेन है:

                     /- ~ --- /:
               /- @ -^- ~.
  /- ~ --- @: -^- {
  |
  |            /- !
--<     /- @ --^- #
  |     |
  \-----<      /- A.
        >- & --^- i.
        \- #

मूल रूप से:

/:~@~.@:{~!@#A.&i.#
          !  A.&     get permutations
           @#   i.#  of range (0..length)
        {~           map indices to chars in string
      @:             then
    ~.               unique
   @                 then
/:~                  sort

Comments

मुझे लगता है कि [:~.i.@!@#A./:~आपको कुछ बाइट्स

— मील

Answer 9

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 129 124 बाइट्स

f=(a,i=-1)=>a[1]?[for(x of a.sort())if(a.indexOf(x)==++i)f([...a.slice(0,i),...a.slice(i+1)]).replace(/^/gm,x)].join`
`:a[0]

बिल्ट-इन बिना परमिशन वाली भाषा के लिए बहुत बुरा नहीं ...

Comments

मैंने इसे स्ट्रिंग्स पर संचालित करने के लिए परिवर्तित किया; केवल 23 बाइट्स लेने के बावजूद पात्रों को क्रम में क्रमबद्ध करने के लिए मुझे अभी भी 120 बाइट्स में काम मिला।

— नील

Answer 10

पायथन 3.5, 81 बाइट्स:

from itertools import*;lambda i:'\n'.join(sorted({*map(''.join,permutations(i))}))

वास्तव में ... 81 बाइट्स जब अगला सबसे लंबा जवाब 48 बाइट्स होता है ... आह । खैर, मैं इस गोल्फ को जितना हो सकता है उतना अधिक करने की कोशिश करूंगा, लेकिन गोल्फ टिप्स अभी भी बहुत सराहना कर रहे हैं।

इसके अलावा, यहां सबसे कम समाधान है जो मैं पायथन 2 में 86 बाइट्स में प्राप्त कर सकता हूं :

from itertools import*;lambda f:'\n'.join(sorted({''.join(i)for i in permutations(f)}))

जाहिरा तौर पर पायथन 2 में, [*...]एक रिटर्न Syntax Error, और के बाद से permutationsरिटर्न itertools.permutations object at 0x..., अगले सबसे छोटा रास्ता (है कि मैं जानता हूँ कि) निकालने की अद्वितीय क्रमपरिवर्तन उपयोग कर रहा है {''.join(i)for i in permutations(f)}, जहां fइनपुट स्ट्रिंग है।

अंत में, ध्यान दें कि ये दोनों लैम्ब्डा फ़ंक्शन हैं और इस प्रकार इसे प्रारूप में कहा जाना चाहिए print(<Function Name>(<Input String>))।

Answer 11

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

Print@@@Permutations@#&

इनपुट में पात्रों की सूची होनी चाहिए।

व्याख्या

Permutations@

इनपुट के सभी क्रमचय, क्रमबद्ध और डुप्लिकेट-मुक्त खोजें।

Print@@@

उन्हें एक एक करके प्रिंट करें।

Answer 12

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

:pfdo~@nw

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

व्याख्या

:pf         Find all outputs of p - Permute with the main Input as input
   d        Remove Duplicates
    o       Order
     ~@n    Concatenate into a single string with linebreaks as separator
        w   Write to STDOUT

Answer 13

पर्ल 6 ,  49  44 बाइट्स

इनपुट के रूप में स्ट्रिंग

*.comb.permutations.sort».join.squish.map: *.put

इनपुट के रूप में वर्णों की सूची

*.permutations.sort».join.squish.map: *.put

विस्तारित

*\              # Whatever lambda
# .comb\        # split into a list of characters
.permutations\  # returns a list of lists
.sort\
».join\         # join the second level lists
.squish\        # remove adjacent repeated values
.map: *.put     # print each on its own line

Comments

हर बार जब मैं पर्ल 6 कोड देखता हूं तो मुझे आश्चर्य होता है कि मैंने इसे अभी तक स्थापित क्यों नहीं किया है

— गेब्रियल बेनामी

@GabrielBenamy एक irc बॉट है जो freenode.net #perl6चैनल पर पर्ल 6 कोड चलाता है ।

— ब्रैड गिलबर्ट ने 21

आप ».sayइसके बजाय कर सकते हैं.map: *.put

— जो किंग

@JoKing तकनीकी रूप ».sayसे उन्हें किसी भी क्रम में करने की अनुमति है, और एक समय में इसे जानबूझकर क्रम से बाहर किया गया था।

— ब्रैड गिल्बर्ट b2gills

Answer 14

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

pᵘoẉᵐ

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

खोजें ᵘnique pइनपुट के ermutations, रों oउन्हें, आर टी ᵐएपी ẉriteln (newline साथ लिख) कि सरणी पर।

Answer 15

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

अब छाँटें!

import itertools as i
for a in sorted(set(i.permutations(input()))):print("".join(a))

Comments

इसे छोटा करने के लिए, आप इसके from itertools import*विपरीत कर सकते हैं import itertools as i। आप को बदल कर एक बाइट को बचाने के लिए सक्षम होगा i.permutationsद्वारा permutations।

— 0WJYxW9FMN

के {*...}बजाय का उपयोग set(...)कर आप दो बाइट्स बचाता है।

— चलत

Answer 16

PowerShell v3 +, 171 बाइट्स

param([char[]]$x)$a,$b=$x;$a=,$a;while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}$a|?{$_.length-eq$x.count}|sort -u

PowerShell v3 ने cmdlet -Uniqueपर ध्वज को पेश किया Sort-Object, इसलिए यह नीचे दिए गए v2 संस्करण से कुछ बाइट्स छोटा है, क्योंकि हमें Selectपहले इसकी आवश्यकता नहीं है ।

v2 संस्करण, 178 बाइट्स:

param([char[]]$x)$a,$b=$x;$a=,$a;while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}$a|?{$_.length-eq$x.count}|select -u|sort

---

PowerShell के पास कोई भी अंतर्निहित परमिट नहीं है, इसलिए मैंने प्राइम फैक्टर के दोस्तों से अपना कोड उधार लिया और यहां उपयोग के लिए इसे थोड़ा ट्वीक किया।

यह अनिवार्य रूप से तीन भाग हैं, जिनका मैं नीचे विस्तार करूँगा।

param([char[]]$x)$a,$b=$x;$a=,$aइनपुट लेता है $x, इसे एक char-रे के रूप में रखता है, पहले अक्षर को $aऔर बाकी में स्ट्रिप्स करता है $b, और फिर $aअल्पविराम के साथ एक सरणी के रूप में पुन: बनाता है ।

while($b){$z,$b=$b;$a+=$a|%{0..($y=($c="$_").Length)|%{-join($c[0..$_]+$z+$c[++$_..$y])};"$z$c";"$c$z"}}शेष अक्षरों ( $b) के माध्यम से लूप्स , प्रत्येक पुनरावृति अगले अक्षर को ले जाता है और इसे स्टोर करता है $zऔर शेष को अंदर छोड़ता है $b, फिर अपने स्वयं के लूप के माध्यम $aसे भेजने के परिणाम पर सरणी-कंक्रीटिंग $a- $a( प्रत्येक आइटम अस्थायी रूप से संग्रहीत $c) पर लूप किया जाता है अपने स्वयं के .length, और फिर $zहर स्थिति में डाला जाता है, जिसमें शामिल है और साथ प्रस्तुत करना $z$cऔर $c$z। उदाहरण के लिए, इसके लिए, $c = '12'और $z = '3'इसके परिणामस्वरूप '132','312','123'वापस समवर्ती किया जाएगा $a।

अंतिम भाग $a|?{$_.length-eq$x.count}|select -u|sortप्रत्येक तत्व को लेता है $aऔर Where-Objectकेवल उन लोगों को फ़िल्टर करने के लिए क्लॉज का उपयोग करता है जिनकी इनपुट स्ट्रिंग के समान लंबाई है, फिर selectकेवल -uनिक आइटम हैं, और अंत में sortउन वर्णानुक्रम में हैं। परिणामी तार सभी पाइप लाइन पर छोड़ दिए जाते हैं, और निहितार्थ के माध्यम से आउटपुट Write-Outputप्रोग्राम पूरा होने पर होता है।

PS C:\Tools\Scripts\golfing> .\alphabetically-permute-a-string.ps1 'PPCG'
CGPP
CPGP
CPPG
GCPP
GPCP
GPPC
PCGP
PCPG
PGCP
PGPC
PPCG
PPGC

Comments

आप 3.0 जाना चाहते हैं, तो आप बदल सकते हैं |select -u|sortकरने के लिए |sort -u। बहुत यकीन है कि 2.0 नहीं है।

— मैट

@ मैट थैंक्स - आप सही हैं। इसे v3 में पेश किया गया था।

— AdmBorkBork

Answer 17

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

f=(s,t=[...s].sort().join``,p=``)=>t?t.replace(/./g,(c,i)=>t.indexOf(c)==i?f(s,t.slice(0,i)+t.slice(i+1),p+c):``):p+`\n`

जहां \nशाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। पोर्ट ऑफ @ ETHproduction के उत्तर सरणियों के बजाय तार का उपयोग करने के लिए। आउटपुट को पीछे करना, या अनुगामी न्यूलाइन को शुरुआत में स्थानांतरित करना, 3 बाइट्स बचाता है।

Answer 18

आर, 113 बाइट्स

x=scan(,"");cat(sort(unique(apply(matrix(x[permute:::allPerms(l<-length(x))],,l),1,paste,collapse=""))),sep="\n")

स्टड से इनपुट पढ़ता है। permuteपैकेज आदेश कॉल करने के लिए में स्थापित होने के लिए माना जाता है allPermsसमारोह।

जैसे ही मुझे काम से घर मिलेगा एक स्पष्टीकरण जोड़ देगा।

Answer 19

जावा 302 300 बाइट्स

import java.util.*;class M{public static void main(String[]a){for(Object s:p(new TreeSet(),"",a[0]))System.out.println(s);}static Set p(Set l,String p,String s){int n=s.length(),i=0;if(n>1)for(;i<n;p(l,p+s.charAt(i),s.substring(0,i)+s.substring(++i,n)));else if(!l.contains(p+=s))l.add(p);return l;}}

Ungolfed और परीक्षण कोड:

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

import java.util.*;
class M{
  static Set p(Set l, String p, String s){
    int n = s.length(),
        i = 0;
    if(n > 1){
      for(; i < n; p(l, p + s.charAt(i), s.substring(0, i) + s.substring(++i, n)));
    } else if(!l.contains(p+=s)){
      l.add(p);
    }
    return l;
  }

  public static void main(String[] a){
    for(Object s : p(new TreeSet(), "", a[0])){
      System.out.println(s);
    }
  }
}

इनपुट: परीक्षण
आउटपुट:

estt
etst
etts
sett
stet
stte
test
tets
tset
tste
ttes
ttse

Comments

क्रमपरिवर्तन को वर्णानुक्रम से माना जाता है

— इक्रॉस

@Ikaros धन्यवाद, अब तय किया जाना चाहिए।

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

Answer 20

रैकेट 82 बाइट्स

(sort(remove-duplicates(map list->string(permutations(string->list s)))) string<?)

Ungolfed:

(define(f s)
 (sort
  (remove-duplicates
   (map
    list->string
    (permutations
     (string->list s))))
  string<?))

परिक्षण:

(f "buzz")

ouput:

'("buzz" "bzuz" "bzzu" "ubzz" "uzbz" "uzzb" "zbuz" "zbzu" "zubz" "zuzb" "zzbu" "zzub")

Answer 21

ग्रूवी, 69 बाइट्स

{(it as List).permutations().unique().sort().each{println it.join()}}

Answer 22

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

->s{puts s.chars.permutation.map(&:join).uniq.sort}

Comments

हम इसे कैसे चला सकते हैं?

— بار:51ابابا

puts s.chars.permutation().map(&:join).uniq43 बाईट

— بار

यह काम नहीं करता है। आपको आउटपुट को क्रमबद्ध करने की आवश्यकता है, और आप sपूर्व परिभाषा के बिना संदर्भित नहीं कर सकते ।

— ली डब्ल्यू

Answer 23

दरअसल , 8 बाइट्स

गोल्फ सुझाव आपका स्वागत है! इसे ऑनलाइन आज़माएं!

;l@╨♂Σ╔i

Ungolfing

     Implicit input s.
;l   Get len(s).
@╨   Get all len(s)-length permutations of s.
♂Σ   Sum them all back into strings.
╔    uniq() the list of strings.
i    Flatten the list of strings.
     Implicit print the stack, separated by newlines.

Answer 24

पिप , 8 बाइट्स

-nध्वज के लिए कोड के 7 बाइट्स, +1 ।

SSUQPMa

कमांड-लाइन तर्क के रूप में एक स्ट्रिंग लेता है। इसे ऑनलाइन आज़माएं!

पिप के स्कैनर ने दो अक्षर के विखंडन में अपरकेस अक्षरों के रन को तोड़ दिया। तो यह कोड है SS UQ PM a-ie SortString(UniQue(PerMutations(a))), aकमांड-लाइन आर्ग होने के साथ । -nझंडा सुनिश्चित परिणाम सूची न्यू लाइन से अलग की गई है। यही सब है इसके लिए।

Answer 25

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

समाधान:

?x@<x@:prm@#x:

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

स्पष्टीकरण:

अंतर्निहित क्रमबद्धता फ़ंक्शन का उपयोग करें prm, इनपुट की लंबाई की क्रमपरिवर्तन उत्पन्न करने के लिए, इन क्रमपरिवर्तन को इनपुट पर लागू करें, वर्णानुक्रम में सॉर्ट करें और फिर अलग-अलग मान लें।

?x@<x@:prm@#x: / the solution
            x: / store input as x
           #   / count length of x
       prm@    / apply (@) function prm
    x@:        / apply indices to x and save result back into x
   <           / indices to sort ascending
 x@            / apply to x
?              / take distint

Answer 26

पर्ल 5 -MList::Util=uniq -F , 68 बाइट्स

$"=',';@b=sort@F;map{say if"@b"eq join$",sort/./g}uniq glob"{@b}"x@b

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

Answer 27

जाप v2.0a0 -R, 5 बाइट्स

á â n

कोशिश करो

Comments

ûकेंद्र pas विधि है; मुझे लगता है कि आपका मतलब है n;)

— झबरा

@ शागिर्द मैंने सिर्फ sortअपने दुभाषिया में सर्चबार में रखा और पहले जो मैंने पाया, उस पर क्लिक किया। लेकिन áलगता है कि प्रत्येक क्रमांकन पहले से ही

— वर्णनात्मक

ओह, यह एक टाइपो है; होना चाहिए ü। मैं कल इसे ठीक कर दूंगा। "बज़" के क्रमांकन को क्रमबद्ध किया जाना चाहिए क्योंकि शब्द ही है - उदाहरण के लिए "ज़ज़ूब" के साथ इसे आज़माएं।

— झबरा

@ शैगी, मैं देख रहा हूं, nइसके साथ अद्यतन उत्तर (यह टाइप करना आसान है)

— अज्ञानता का अवतार

Answer 28

सी ++ (जीसीसी) , 132 128 बाइट्स

#include<bits/stdc++.h>
using namespace std;int main(){string s;for(cin>>s;cout<<s<<endl,next_permutation(s.begin(),s.end()););}

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

Answer 29

क्लैम , 9 बाइट्स

p_D`Sq@~Q

व्याख्या

          - Implicit Q = first input
p         - Print...
 _        - Sorted ascending value (alphabetical order)
  D       - Distinct from...
   `Sq    - Joined (map(q=>q.join(""))
      @~Q - Permutations of Q