งาน

เป้าหมายของคุณถ้าคุณเลือกที่จะยอมรับมันก็คือการเขียนโปรแกรมที่รับสายอักขระ (หรืออาเรย์ของอักขระ) ออกผลลัพธ์ที่เป็นไปได้ของการเรียงลำดับตัวอักษรในสตริงนั้น ฉันจู้จี้จุกจิกกับผลลัพธ์ของฉันดังนั้นจึงควรเรียงลำดับตัวอักษรโดยไม่มีการซ้ำซ้อน

ตัวอย่าง:

การป้อนข้อมูล: buzz

เอาท์พุท:

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

กฎระเบียบ

• นี่คือโค้ดกอล์ฟเพื่อให้โค้ดที่สั้นที่สุดชนะ
• ช่องว่างต่อท้ายในแต่ละ / บรรทัดใด ๆ ก็โอเค
• บรรทัดใหม่เดียวหลังจากบรรทัดสุดท้ายได้รับอนุญาต (แต่ไม่เกิน)

เยลลี่ 5 ไบต์

ṢŒ!QY

ลองออนไลน์!

คำอธิบาย

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

05AB1E ,  4  3 ไบต์

อัปเดตตั้งแต่การอัปเดตจนถึงœเวอร์ชันเก่า
ซึ่งยังบันทึกไว้ไบต์ตามที่แนะนำโดยเมจิกปลาหมึกโกศ

œê»

ลองออนไลน์!

คำอธิบาย

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

MATL , 4 ไบต์

Y@Xu

ลองออนไลน์!

คำอธิบาย

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

Python 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เมื่อป้อนข้อมูลหมดเราพิมพ์

CJam , 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

Pyth - 5 ไบต์

jS{.p

ลองมันออนไลน์ได้ที่นี่

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

Haskell, 46 ไบต์

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

บันทึก 2 ไบต์ขอบคุณ nimi

J, 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

JavaScript (Firefox 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]

ไม่เลวเกินไปสำหรับภาษาที่ไม่มีบิวด์อินการเปลี่ยนแปลง ...

Python 3.5, 81 ไบต์:

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

จริง ๆ ... 81 ไบต์เมื่อคำตอบที่ยาวที่สุดถัดไปคือ 48 ไบต์ ... ถอนหายใจถอนหายใจฉันจะลองเล่นกอล์ฟนี้ให้มากที่สุดเท่าที่ทำได้

นอกจากนี้นี่เป็นทางออกที่สั้นที่สุดที่ฉันจะได้รับใน Python 2 ที่86 ไบต์ :

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

เห็นได้ชัดใน Python 2 [*...]คืนค่า a Syntax Errorและเนื่องจากpermutationsคืนค่าitertools.permutations object at 0x...วิธีที่สั้นที่สุดถัดไป (ที่ฉันรู้) ของการแยกการเรียงสับเปลี่ยนที่ไม่ซ้ำกันคือการใช้{''.join(i)for i in permutations(f)}ตำแหน่งfเป็นสตริงอินพุต

print(<Function Name>(<Input String>))สุดท้ายทราบว่าสิ่งเหล่านี้มีทั้งฟังก์ชั่นแลมบ์ดาจึงต้องเรียกว่าในรูปแบบ

Mathematica, 34 23 ไบต์

Print@@@Permutations@#&

อินพุตต้องเป็นรายการอักขระ

คำอธิบาย

Permutations@

ค้นหาพีชคณิตทั้งหมดของการป้อนข้อมูลเรียงลำดับและซ้ำกันฟรี

Print@@@

พิมพ์ทีละคน

Brachylogขนาด 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

Perl 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

Brachylog (v2), 5 ไบต์

pᵘoẉᵐ

ลองออนไลน์!

ค้นหาᵘnique permutations ของการป้อนข้อมูล, s ort พวกเขาᵐ AP ẉriteln (เขียนด้วยการขึ้นบรรทัดใหม่) มากกว่าอาร์เรย์ที่

Python 3, 77 85 ไบต์

ตอนนี้ทุกประเภท!

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

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 แนะนำการ-Uniqueตั้งค่าสถานะบนSort-Objectcmdlet ดังนั้นจึงสั้นกว่ารุ่น 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 ไม่มีการเรียงสับเปลี่ยนในตัวดังนั้นฉันยืมรหัสของฉันจากPrime Factors Buddiesและปรับแต่งเล็กน้อยเพื่อใช้ที่นี่

นี่คือส่วนที่สามซึ่งฉันจะขยายด้านล่าง

param([char[]]$x)$a,$b=$x;$a=,$aนำข้อมูลป้อน$x, ปลดเปลื้องมันเป็นchar-array, ตัดตัวอักษรตัวแรกเข้า$aและส่วนที่เหลือเข้าไป$b, จากนั้น recasts $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ถูกแทรกเข้าไปในทุกตำแหน่งรวมทั้ง prepending และต่อท้ายด้วยและ$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ที่ไม่ซ้ำกันและสุดท้ายจะเรียงตามลำดับตัวอักษร สตริงผลลัพธ์จะถูกทิ้งไว้บนไพพ์ไลน์และเอาต์พุตผ่านทาง implicit 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

JavaScript (ES6), 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หมายถึงอักขระ newline ที่แท้จริง คำตอบของพอร์ตของ @ ETHProduction เพื่อใช้สตริงแทนอาร์เรย์ การย้อนกลับเอาต์พุตหรือย้ายบรรทัดใหม่ต่อท้ายไปยังจุดเริ่มต้นบันทึก 3 ไบต์

R, 113 ไบต์

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

อ่านอินพุตจาก stdin permuteแพคเกจจะถือว่าติดตั้งเพื่อเรียกallPermsฟังก์ชั่น

จะเพิ่มคำอธิบายเมื่อฉันกลับถึงบ้านจากที่ทำงาน

Java 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

แร็กเก็ต 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")

Groovy, 69 Bytes

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

Ruby, 51 bytes

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

Actually, 8 bytes

Golfing suggestions welcome! Try it online!

;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.

Pip, 8 bytes

7 bytes of code, +1 for -n flag.

SSUQPMa

Takes a string as a command-line argument. Try it online!

Pip's scanner breaks runs of uppercase letters into two-letter chunks. So this code is SS UQ PM a--i.e. SortString(UniQue(PerMutations(a))), with a being the command-line arg. The -n flag ensures the result list is newline-separated. That's all there is to it.

K (oK), 14 bytes

Solution:

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

Try it online!

Explanation:

Use the built-in permutation function, prm, to generate permutations of length of the input, apply these permutations to the input, sort alphabetically and then take distinct values.

?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

Perl 5 -MList::Util=uniq -F, 68 bytes

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

Try it online!

Japt v2.0a0 -R, 5 bytes

á â n

Try it

C++ (gcc), 132 128 bytes

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

Try it online!

Clam, 9 bytes

p_D`Sq@~Q

Explanation

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