Dada uma lista de cadeias únicas que são anagramas uma da outra, produza um anagrama daquelas palavras que são diferentes de cada palavra da lista.

As strings serão alfanuméricas e é garantido que haja um anagrama válido.

O programa ou função pode, mas não precisa ser não determinístico, ou seja, dada a mesma entrada, a execução múltipla de um código pode produzir saídas diferentes, desde que todas as saídas possíveis sejam válidas.

Casos de teste

[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 bytes

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

Experimente online!

05AB1E , 5 bytes

нœ¹мà

Experimente online!

Explicação

нœ¹мà

н     // 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)

Pitão , 5 bytes

h-.ph

Experimente online!

Explicação

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

Gelatina , 6 bytes

XŒ!ḟµḢ

Experimente online!

1 byte a mais que a resposta 05AB1E e Pyth.

Explicação:

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.

Eu escolhi Xporque é a maneira mais curta que eu conheço de escolher qualquer elemento da lista sem alterar a lista ( Ḣe Ṫnão funciona, ḷ/e ṛ/é mais longa), e isso causa alguma aleatoriedade.

O µaqui é bastante redundante, mas sem ele, Ḣseria emparelhado com o ḟe é interpretado como "filtrar a cabeça da entrada", que não é o que eu preciso aqui (o que eu preciso é "filtrar a entrada, e pegue a cabeça ").

Javascript, 118 bytes

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

usa um randomizador ruim para iterar sobre cada permutação "aleatória".

Provavelmente errado, mas, apesar do aleatorizador ruim, significa que não obteremos a aleatoriedade verdadeira, mas ainda assim obteremos toda permutação.

Parece funcionar em todos os casos no chrome para mim, mas aparentemente devido a um comportamento indefinido nesse tipo de abuso, ele não pode funcionar em alguns navegadores.

(Provavelmente muito despreocupado, fique à vontade para aprimorá-lo em suas próprias soluções)

80 bytes

Graças ao comentário de pirateBay - muitos bytes

-4 bytes graças a Rick

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

Haskell , 58 bytes

-1 byte e uma correção graças a Laikoni.

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

Experimente online!

Provavelmente não vale a pena importar Data.Listpara permutações, mas eh.

Ruby , 46 bytes

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

Experimente online!

Braquilog , 7 bytes

hp.¬∈?∧

Experimente online!

Explicação

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 bytes

não determinístico

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

Experimente online!

Mathematica, 56 bytes

determinista

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

Experimente online!

Japonês , 7 6 bytes

-1 byte graças a @Shaggy

á kN ö

Experimente online!

Toma seqüências de caracteres de entrada como várias entradas em vez de como uma matriz. Emite uma permutação aleatória; mude öpara gpara obter o primeiro.

Explicação

á 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 bytes

1X)Y@Z{GX-1)

Experimente online!

Economizou 2 bytes graças a Sanchises. setdiff(...,'rows')é mais curto que negar ismember(...,'rows')e evita uma duplicação. Economizou outro byte graças a Luis Mendo, alternando para células em vez de matrizes.

Explicação:

Os equivalentes MATLAB / Oitava também estão incluídos.

                 % 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

A entrada deve estar no formato {'abc', 'acb'}.

Python 3 , 78 bytes

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

Experimente online!

-1 byte graças ao Sr. Xcoder

Pip , 11 bytes

@:_NIgFIPMa

Toma as entradas como argumentos da linha de comando. Experimente online!

Explicação

          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 bytes

Acredito que esta seja a única submissão até agora que não usa uma permutação incorporada nem uma aleatória aleatória / classificação. Embora seja mais longo, acho que o algoritmo é bem organizado.

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]

Experimente online!

Explicação

O que estamos fazendo é basicamente isso:

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

Aqui está uma prova de que funciona:

Para uma sequência S, defina front(S)como o conjunto de sequências obtido escolhendo um caractere Se movendo-o para a frente de S. Por exemplo, front(ABCDE)é {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Agora considere uma lista de anagramas L, de modo que Lnão contenha todos os anagramas possíveis (conforme a descrição do problema). Queremos mostrar que existe uma corda Sem Ltal que front(S)contém pelo menos um anagrama S'que não está em L.

Suponha, por meio de contradição, que, para cada string Sin L, toda string in front(S)também esteja L. Observe que podemos gerar uma permutação arbitrária de qualquer string por meio de uma série de movimentos "de frente". Por exemplo, para obter

ABCDE -> BAEDC

nós podemos fazer

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

Assumimos que, para cada S, em L, cada S', em front(S)também está L. Isso também significa que todo S''in front(S')está dentro Le assim por diante. Portanto, se Sestiver dentro L, toda permutação de Stambém está dentro L. Então Ldeve haver um conjunto completo de anagramas, uma contradição.

Então, uma vez que está garantido que haja pelo menos uma permutação não em L, deve existir uma corda Sno Lpara o qual alguns S'na front(S)não está na L. QED.

O código itera front(S)para cada Sem Le selecciona um S'que não está em L. Pelo resultado acima, haverá pelo menos um S'que se qualifica.

C # (Compilador interativo do Visual C #) , 116 96 bytes

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

Minhas habilidades no golfe certamente melhoraram desde quando publiquei isso pela primeira vez!

Experimente online!

JavaScript (ES7), 172 bytes

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

Encontre a primeira permutação lexicográfica do primeiro elemento da matriz que não está contida na matriz.

Kotlin , 104 bytes

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

Embelezado

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

Teste

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 bytes

#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;}

Experimente online!

Scala, 50 bytes

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

Experimente online!

Explicação

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 bytes

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

Faça amostragens repetidas das letras da primeira entrada (como devem ser anagramas umas das outras) e pare quando uma dessas amostras não estiver na lista original.

Casca , 6 bytes

←-⁰P←⁰

Experimente online!

PHP , 70 bytes

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

Execute em um servidor da Web, inserindo 0 valores de obtenção indexados ou Experimente online!

Ungolfed

$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 bytes

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

não determinístico; recebe entrada dos argumentos da linha de comando

Corra com php -r <code>palavras seguidas por espaços separados ou tente online .

Anexo , 16 bytes

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

Experimente online!

Explicação

&\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

Alternativas

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

18 bytes :{&\S! !Id@_[0]Ø_}

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

26 bytes :{&\S!Permutations@_[0]Ø_}

26 bytes :{&\S!Permutations[_@0]Ø_}

26 bytes :{(Permutations[_@0]Ø_)@0}

26 bytes :&\S##~`Ø#Permutations@&\S

27 bytes :Last@{Permutations[_@0]Ø_}

27 bytes :`@&0@{Permutations[_@0]Ø_}

28 bytes :Last##~`Ø#Permutations@&{_}

28 bytes :Last##~`Ø#Permutations@Last

28 bytes :First@{Permutations[_@0]Ø_}

30 bytes :{NestWhile[Shuffle,`in&_,_@0]}

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

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

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

J , 25 bytes

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

A entrada é uma lista de seqüências de caracteres em caixa - eu senti que era justo assim e não declarar as listas de sequências explicitamente como 4 8 $ 'abcde123', 'ab3e1cd2', '321edbac', 'bcda1e23'.

Eu não gosto da bagunça @ no meu código, mas há muitos verbos serializados dessa vez.

Como funciona:

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

Experimente online!

05AB1E , 5 bytes

нœIмà

Experimente online!

Explicação

нœ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

Praticamente a mesma resposta que @ThePirateBay encontrou.

JavaScript, 87 bytes

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

Experimente online!

Esta resposta é baseada (embora fortemente modificada) na resposta de Imme . Ele sugeriu em um comentário que essa deveria ser uma resposta diferente.

O problema com a abordagem antiga é porque sorté completamente dependente da implementação. O padrão não garante a ordem de chamar a função de classificação, portanto, teoricamente, nunca pode terminar no primeiro ou no segundo caso de teste.

Essa abordagem tem alguns bytes a mais, mas garante que será concluída em tempo restrito, mesmo que Math.randomnunca retorne .5.

CJam , 11 bytes

q~_0=m!\m0=

Experimente online!

Explicação

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 bytes

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

Experimente online!

Aleatoriamente embaralha a primeira sequência da entrada até que não seja um elemento da entrada.

Explicação:

{(.[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