Biorąc pod uwagę listę unikatowych ciągów, które są wzajemnie anagramami, wypisz anagram tych słów, który różni się od każdego słowa na liście.

Ciągi będą alfanumeryczne i na pewno będzie prawidłowy anagram.

Program lub funkcja może, ale nie musi być niedeterministyczna, co oznacza, że ​​przy tym samym wejściu wielokrotne uruchomienie kodu może dawać różne dane wyjściowe, o ile każde możliwe wyjście jest prawidłowe.

Przypadki testowe

[Input] -> Possible output
-----------------
[ab] -> ba
[aba, aab] -> baa
[123, 132, 231, 312, 321] -> 213
[hq999, 9h9q9, 9qh99] -> 999hq
[abcde123, ab3e1cd2, 321edbac, bcda1e23] -> ba213ecd

Python 3 , 64 bajty

lambda a:[*{*permutations(a[0])}-{*a}][0]
from itertools import*

Wypróbuj online!

05AB1E , 5 bajtów

нœ¹мà

Wypróbuj online!

Wyjaśnienie

нœ¹мà

н     // Get the first element of the input list
 œ    // Generate all permutations
  ¹   // Push the input again
   м  // In the permutations list, replace all strings that
      //   are in the input list with empty strings
    à // Pick the string with the greatest lexicographic
      //   index (in this case a non-empty string)

Pyth , 5 bajtów

h-.ph

Wypróbuj online!

Wyjaśnienie

h-.ph
    h    First string in [the input]
  .p     All permutations
 -       Remove those in [the input]
h        First element.

Galaretka , 6 bajtów

XŒ!ḟµḢ

Wypróbuj online!

1 bajt więcej niż 05AB1E i odpowiedź Pyth.

Wyjaśnienie:

XŒ!ḟµḢ   Main program.
 Œ!      All permutation of...
X        any element from the word list.
   ḟ     Filter out (remove) all the elements in the original word list.
    µ    With the filtered-out list,
     Ḣ   pick the first element.

Wybrałem, Xponieważ jest to najkrótszy znany mi sposób na wybranie dowolnego elementu z listy bez zmiany listy ( Ḣi Ṫnie działa, ḷ/i ṛ/jest dłuższy), a czasami powoduje losowość.

µTutaj jest całkiem zbędne, ale bez niej Ḣbyłoby połączone z ḟ, i to jest interpretowane jako „odfiltrować szefa wejścia”, co nie jest, co muszę tu (co jest mi potrzebne „filtr na wejściu, i zdobądź głowę ”).

JavaScript, 118 bajtów

function f(a){s=a[0];while(a.indexOf(s)!=-1)s=s.split("").sort(function(){return .5-Math.random()).join("")};return s}

używa złego randomizatora do iteracji po każdej „losowej” permutacji.

Prawdopodobnie źle, ale afaik zły randomizer oznacza po prostu, że nie otrzymamy prawdziwej przypadkowości, ale nadal otrzymamy każdą permutację.

Wydaje mi się, że działa we wszystkich przypadkach w chrome dla mnie, ale najwyraźniej z powodu nieokreślonego zachowania w tego rodzaju nadużyciach, nie może działać w niektórych przeglądarkach.

(Prawdopodobnie bardzo nierozpoznany nie krępuje się ulepszać go we własnych rozwiązaniach)

80 bajtów

Dzięki komentarzowi pirateBay - dużo bajtów

-4 bajty dzięki Rickowi

f=a=>eval('s=[...a[0]].sort(()=>.5-Math.random()).join``;a.indexOf(s)<0?s:f(a)')

Haskell , 58 bajtów

-1 bajt i poprawka dzięki Laikoni.

import Data.List
f l=[i|i<-permutations$l!!0,all(/=i)l]!!0

Wypróbuj online!

Prawdopodobnie nie warto importować Data.Listdla permutacji, ale eh.

Rubinowy , 46 bajtów

->l{(l[0].chars.permutation.map(&:join)-l)[0]}

Wypróbuj online!

Brachylog , 7 bajtów

hp.¬∈?∧

Wypróbuj online!

Wyjaśnienie

hp.        The Output is a permutation of the first element of the Input
  .¬∈?     The Output is not a member of the Input
      ∧    (Disable implicit Input = Output)

Mathematica, 57 bajtów

niedeterministyczny

(While[!FreeQ[#,s=""<>RandomSample@Characters@#&@@#]];s)&

Wypróbuj online!

Mathematica, 56 bajtów

deterministyczny

#&@@Complement[""<>#&/@Permutations@Characters@#&@@#,#]&

Wypróbuj online!

Japt , 7 6 bajtów

-1 bajt dzięki @Shaggy

á kN ö

Wypróbuj online!

Pobiera ciągi wejściowe jako kilka danych wejściowych zamiast jako tablicę. Wyprowadza losową permutację; przełącz się öna, gaby otrzymać pierwszy.

Wyjaśnienie

á kN ö  Implicit input: N = array of input strings
á       Get all permutations of the first input string
  kN    Remove all input strings from those
     ö  Get a random element from the array. Implicit output

MATL , 15 , 13 , 12 bajtów

1X)Y@Z{GX-1)

Wypróbuj online!

Zaoszczędzono 2 bajty dzięki Sanchises. setdiff(...,'rows')jest krótszy niż negowanie ismember(...,'rows')i pozwala uniknąć jednego powielania. Zaoszczędził kolejny bajt dzięki Luisowi Mendo, przełączając się na komórki zamiast na tablice.

Wyjaśnienie:

Uwzględniono również odpowiedniki MATLAB / Octave.

                 % Implicitly grab input x containing cells of strings
1X)              % Get first cell. Equivalent to x{1}
   Y@            % All permutations of first row input. Equivalent to p=perms(y)
      Z{         % Convert the list of permutations to a cell array
        G        % Grab input again      
         X-      % setdiff, comparing the input cells with the permutations
           1)    % The first of the results

Dane wejściowe muszą mieć jeden format {'abc', 'acb'}.

Python 3 , 78 bajtów

lambda a:[x for x in permutations(a[0])if~-(x in a)][0]
from itertools import*

Wypróbuj online!

-1 bajt dzięki Mr. Xcoder

Pip , 11 bajtów

@:_NIgFIPMa

Pobiera dane wejściowe jako argumenty wiersza polecenia. Wypróbuj online!

Wyjaśnienie

          a  1st cmdline arg
        PM   List of all permutations
      FI     Filter on this function:
  _NIg         Permutation not in cmdline args
@:           First element of resulting list (with : meta-operator to lower precedence)
             Autoprint

Python 3 , 87 bajtów

Uważam, że jest to jedyne jak dotąd zgłoszenie, które nie wykorzystuje ani wbudowanej permutacji, ani losowego losowania / sortowania. Mimo że jest dłuższy, algorytm jest całkiem fajny.

lambda L:[p for s in L for i,c in enumerate(s)for p in[c+s[:i]+s[i+1:]]if~-(p in L)][0]

Wypróbuj online!

Wyjaśnienie

To, co robimy, to w zasadzie:

def unique_anagram(string_list):
    for string in string_list:
        for i, char in enumerate(string):
            # Move the character to the beginning of the string
            permutation = char + string[:i] + string[i+1:]
            if permutation not in string_list:
                return permutation

Oto dowód, że to działa:

Dla ciągu Szdefiniuj front(S)jako zestaw ciągów uzyskany poprzez wybranie jednego znaku Si przeniesienie go na przód S. Na przykład front(ABCDE)jest {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Rozważmy teraz listę anagramów L, która Lnie zawiera wszystkich możliwych anagramów (zgodnie z opisem problemu). Chcemy pokazać, że istnieje ciąg Sw Ltaki sposób, że front(S)zawiera co najmniej jeden anagram S', który nie jest w L.

Przypuśćmy, na zasadzie sprzeczności, że dla każdej struny Sw Lkażdy ciąg w front(S)jest również L. Zauważ, że możemy wygenerować dowolną permutację dowolnego łańcucha za pomocą serii ruchów „frontingowych”. Na przykład, aby uzyskać

ABCDE -> BAEDC

możemy zrobić

ABCDE -> CABDE -> DCABE -> EDCAB -> AEDCB -> BAEDC

Założyliśmy, że dla każdego SIN L, każdy S'w front(S)to również L. To oznacza również, że każdy S''w front(S')znajduje się w L, i tak dalej. Dlatego, jeśli Sjest w L, każda permutacja w Sjest również w L. Zatem Lmusi być kompletny zestaw anagramów, sprzeczność.

Tak, ponieważ mamy zagwarantowane, że istnieje co najmniej jedna permutacja nie w L, musi istnieć ciąg Sw Lodniesieniu do których niektórzy S'w front(S)nie jest L. CO BYŁO DO OKAZANIA.

Kod iteruje front(S)dla każdego Sw Li wybiera S', które nie jest L. Na podstawie powyższego wyniku będzie co najmniej jeden, S'który się kwalifikuje.

C # (interaktywny kompilator Visual C #) , 116 96 bajtów

s=>{for(var g="";;)if(s.All(z=>z!=(g=string.Concat(s[0].OrderBy(t=>Guid.NewGuid())))))return g;}

Moje umiejętności gry w golfa na pewno poprawiły się od czasu, gdy opublikowałem to po raz pierwszy!

Wypróbuj online!

JavaScript (ES7), 172 bajty

f=(a,s=a[0],b=[...s],k=b.findIndex((e,i)=>s[i-1]>e))=>a.includes(s)?f(a,(~k?(t=b[k],b[k]=b[l=a.findIndex(e=>e>t)],b[l]=t,b.map((e,i)=>i<k?b[k+~i]:e)):b.reverse()).join``):s

Znajdź pierwszą permutację leksykograficzną pierwszego elementu tablicy, który nie jest zawarty w tablicy.

Kotlin , 104 bajty

{var r=""
do{r=it[0].map{it to Math.random()}.sortedBy{(_,b)->b}.fold("",{a,(f)->a+f})}while(r in it)
r}

Upiększony

{
    var r = ""
    do {
        r = it[0].map { it to Math.random() }
            .sortedBy { (_, b) -> b }
            .fold("", { a, (f) -> a + f })
    } while (r in it)
    r
}

Test

var ana: (List<String>) -> String =
{var r=""
do{r=it[0].map{it to Math.random()}.sortedBy{(_,b)->b}.fold("",{a,(f)->a+f})}while(r in it)
r}

fun main(args: Array<String>) {
    println(ana(listOf("ab")))
}

C ++, 169 bajtów

#import<set>
#import<string>
#import<algorithm>
using S=std::string;S f(std::set<S>l){S s=*l.begin();for(;l.count(s);)std::next_permutation(s.begin(),s.end());return s;}

Wypróbuj online!

Scala, 50 bajtów

(l:Seq[String])=>(l(0).permutations.toSet--l).head

Wypróbuj online!

Wyjaśnienie

l(0)         // Take the first anagram
permutations // Built-in to get all permutations
toSet        // Convert to set, required for -- function
-- l         // Remove the original anagrams
head         // Take a random element from the set

R, 89 bajtów

x=scan(,'');repeat{a=paste(sample(el(strsplit(x[1],''))),collapse='');if(!a%in%x)break};a

Wielokrotnie próbkuj litery z pierwszego wpisu (tak jak powinny być one wzajemnymi anagramami) i zatrzymaj się, gdy jedna z tych próbek nie będzie na oryginalnej liście.

Łuska , 6 bajtów

←-⁰P←⁰

Wypróbuj online!

PHP , 70 bajtów

$j=1;while($j){$g=str_shuffle($_GET[0]);$j=in_array($g,$_GET);}echo$g;

Uruchom na serwerze WWW, wpisując 0 zindeksowanych wartości lub Wypróbuj online!

Nie golfił

$j=1; //set truty value
while($j){ 
    $g=str_shuffle($_GET[0]); //shuffle the first anagram of the set
    $j=in_array($g,$_GET); //see if in the set, if false, the loop ends
}
echo $g;

PHP, 58 55 bajtów

while(in_array($s=str_shuffle($argv[1]),$argv));echo$s;

niedeterministyczny; pobiera dane wejściowe z argumentów wiersza poleceń

Uruchom ze php -r <code>słowami oddzielonymi spacjami lub wypróbuj online .

Attache , 16 bajtów

&\S@{!S@_[0]Ø_}

Wypróbuj online!

Wyjaśnienie

&\S@{!S@_[0]Ø_}
    {         }    lambda (input: `_`)
        _[0]       first element of the given array
       @           pass to:
     !                 on each permutation:
      S                cast to string
            Ø      without any member of
             _     the input
                   this gives all anagrams not in the input
   @               then
&\S                "first string element"
&                  spread input array over each individual arguments
 \                 tale first argument
  S                as a string

Alternatywy

17 bajtów :{&\S! !S@_[0]Ø_}

18 bajtów :{&\S! !Id@_[0]Ø_}

19 bajtów :{&\S!(!Id)@_[0]Ø_}

26 bajtów :{&\S!Permutations@_[0]Ø_}

26 bajtów :{&\S!Permutations[_@0]Ø_}

26 bajtów :{(Permutations[_@0]Ø_)@0}

26 bajtów :&\S##~`Ø#Permutations@&\S

27 bajtów :Last@{Permutations[_@0]Ø_}

27 bajtów :`@&0@{Permutations[_@0]Ø_}

28 bajtów :Last##~`Ø#Permutations@&{_}

28 bajtów :Last##~`Ø#Permutations@Last

28 bajtów :First@{Permutations[_@0]Ø_}

30 bajtów :{NestWhile[Shuffle,`in&_,_@0]}

33 bajty :{If[(q.=Shuffle[_@0])in _,$@_,q]}

33 bajty :{q.=Shuffle[_@0]If[q in _,$@_,q]}

34 bajty :{If[Has[_,q.=Shuffle[_@0]],$@_,q]}

J , 25 bajtów

((A.~i.@!@#)@{.@:>){.@-.>

Dane wejściowe to lista ciągów w ramkach - czułem, że było to sprawiedliwe i nie deklarowałem jawnie list ciągów jako 4 8 $ „abcde123”, „ab3e1cd2”, „321edbac”, „bcda1e23”.

Nie podoba mi się @ bałagan w moim kodzie, ale tym razem jest wiele serializowanych czasowników.

Jak to działa:

                         >  - unboxes the strings
 (                 )        - left verb of the fork as follows:
             @{.@:>         - unbox and take the first string
  (         )               - finds all permutations of the first string
      i.@!@#                - a list 0 .. the factorial of the length of the 1st string
   A.~                      - anagram index, all permutations
                    {.@-.   - remove the inital strings and take the first of the remaining

Wypróbuj online!

05AB1E , 5 bajtów

нœIмà

Wypróbuj online!

Wyjaśnienie

нœIмà full program with implicit input i
н     push first element of i
 œ    push all permutations
  I   push input i
   м  remove all elements of i from the permutations
    à extract greatest element and print implicitly

Prawie ta sama odpowiedź, którą znalazła @ThePirateBay.

JavaScript, 87 bajtów

a=>eval('for(s=[...a[0]];(a+[]).includes(k=s.sort(a=>~-(Math.random``*3)).join``););k')

Wypróbuj online!

Ta odpowiedź jest (choć mocno zmodyfikowana) odpowiedzią Imme . W komentarzu zasugerował, że powinna to być inna odpowiedź.

Problem ze starym podejściem polega na tym, że sort jest całkowicie zależny od implementacji. Standard nie gwarantuje kolejności wywoływania funkcji sortowania, dlatego teoretycznie może się nigdy nie skończyć dla pierwszego lub drugiego przypadku testowego.

Takie podejście jest o kilka bajtów dłuższe, ale gwarantuje, że zakończy się w ograniczonym czasie, nawet jeśli Math.randomnigdy nie powróci .5.

CJam , 11 bajtów

q~_0=m!\m0=

Wypróbuj online!

Wyjaśnienie

q~  e# Read input and evaluate: ["123" "132" "231" "312" "321"]
_   e# Duplicate:               ["123" "132" "231" "312" "321"] ["123" "132" "231" "312" "321"]
0=  e# First:                   ["123" "132" "231" "312" "321"] "123"
m!  e# Permutations:            ["123" "132" "231" "312" "321"] ["123" "132" "213" "231" "312" "321"]
\   e# Swap:                    ["123" "132" "213" "231" "312" "321"] ["123" "132" "231" "312" "321"]
m0  e# Subtract, push 0:        ["213"] 0
    e# (m is used instead of - when in front of a digit)
=   e# Get item:                "213"

Perl 6 , 42 bajtów

{(.[0],*.comb.pick(*).join...*∉$_)[*-1]}

Wypróbuj online!

Losowo tasuje pierwszy ciąg danych wejściowych, dopóki nie będzie on elementem danych wejściowych.

Wyjaśnienie:

{(.[0],*.comb.pick(*).join...*∉$_)[*-1]}
{                                      }   # Anonymous code block
 (                        ...    )   # Create a sequence
  .[0],   # The first element is the first element of the input
       *.comb.pick(*).join   # Each element is the previous one shuffled
                             *∉$_   # Until it is not in the input
                                  [*-1]   # Return the last element