задача

Ваша цель, если вы решите принять ее, - написать программу, которая при заданной входной строке (или массиве символов) выводит каждую возможную перестановку букв в этой строке. Я привередлив в своем выводе, поэтому он должен быть отсортирован по алфавиту, без дубликатов.

Пример:

Входные данные: 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 байта

Обновленный, так как обновление œсломало старую версию,
которая также сохранила байт, как было предложено Magic Octopus Urn .

œê»

Попробуйте онлайн!

объяснение

œ     # 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@@@

Распечатайте их один за другим.

Брахилог , 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 ввода, с oк.т. их, ᵐар ẉ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-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 не имеет встроенных перестановок, поэтому я позаимствовал мой код у Prime Factors Buddies и немного подправил его для использования здесь.

По сути, это три части, которые я расскажу ниже.

param([char[]]$x)$a,$b=$x;$a=,$aПринимает данные $x, charпреобразует их как -array, удаляет первую букву, $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предложение, чтобы отфильтровать только те, которые имеют ту же длину, что и входная строка, затем selects только -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

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представляет буквальный символ новой строки. Порт ответа @ ETHproduction на использование строк вместо массивов. Обратный вывод или перемещение завершающего символа новой строки в начало экономит 3 байта.

R 113 байтов

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

Читает ввод из стандартного ввода. Предполагается, что 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 байт

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

Рубин, 51 байт

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

На самом деле , 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.

Пип , 8 байт

7 байтов кода, +1 за -nфлаг.

SSUQPMa

Принимает строку в качестве аргумента командной строки. Попробуйте онлайн!

Сканер Пипа разбивает серии заглавных букв на две буквы. Итак, этот код SS UQ PM a--ie SortString(UniQue(PerMutations(a))), с aаргументом командной строки arg. В -nфлаге обеспечивает список результата новая строка , разделенная. Это все, что нужно сделать.

K (ок) , 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

Perl 5 -MList::Util=uniq -F , 68 байт

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

Попробуйте онлайн!

Japt v2.0a0 -R, 5 байт

á â n

Попытайся

C ++ (gcc) , 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()););}

Попробуйте онлайн!

Моллюск , 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