Dada una lista de cadenas únicas que son anagramas entre sí, genera un anagrama de esas palabras que es diferente de cada palabra en la lista.

Las cadenas serán alfanuméricas, y se garantiza que habrá un anagrama válido.

El programa o función puede, pero no tiene que ser no determinista, lo que significa que, dada la misma entrada, la ejecución múltiple de un código puede producir diferentes salidas, siempre que cada salida posible sea válida.

Casos de prueba

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

Pruébalo en línea!

05AB1E , 5 bytes

нœ¹мà

Pruébalo en línea!

Explicación

нœ¹мà

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

h-.ph

Pruébalo en línea!

Explicación

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

Jalea , 6 bytes

XŒ!ḟµḢ

Pruébalo en línea!

1 byte más que el 05AB1E y la respuesta Pyth.

Explicación:

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.

Elegí Xporque es la forma más corta que conozco para elegir cualquier elemento de la lista sin alterar la lista ( Ḣy Ṫno funciona, ḷ/y ṛ/es más larga), y resulta que causa algo de aleatoriedad.

El µaquí es bastante redundante, pero sin él, Ḣse emparejaría con el ḟ, y se interpreta como "filtrar la cabeza de la entrada", que no es lo que necesito aquí (lo que necesito es "filtrar la entrada, y obtener la cabeza ").

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}

utiliza un aleatorizador incorrecto para iterar sobre cada permutación "aleatoria".

Probablemente sea incorrecto, pero afaik, el aleatorizador incorrecto solo significa que no obtendremos una aleatoriedad verdadera, pero aún obtendremos cada permutación.

Parece funcionar en todos los casos en Chrome para mí, pero aparentemente debido a un comportamiento indefinido en este tipo de abuso, no puede funcionar en algunos navegadores.

(Probablemente muy poco golfista siéntase libre de mejorarlo en sus propias soluciones)

80 bytes

Gracias al comentario de pirateBay -muchos bytes

-4 bytes gracias 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 y una solución gracias a Laikoni.

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

Pruébalo en línea!

Probablemente no valga la pena importar Data.Listpara permutaciones, pero eh.

Ruby , 46 bytes

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

Pruébalo en línea!

Brachylog , 7 bytes

hp.¬∈?∧

Pruébalo en línea!

Explicación

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

no determinista

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

Pruébalo en línea!

Mathematica, 56 bytes

determinista

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

Pruébalo en línea!

Japt , 7 6 bytes

-1 byte gracias a @Shaggy

á kN ö

Pruébalo en línea!

Toma las cadenas de entrada como varias entradas en lugar de como una matriz. Emite una permutación aleatoria; cambie öa gpara obtener el primero.

Explicación

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

Pruébalo en línea!

Guardado 2 bytes gracias a Sanchises. setdiff(...,'rows')es más corto que negar ismember(...,'rows')y evita una duplicación. Ahorré otro byte gracias a Luis Mendo, al cambiar a celdas en lugar de matrices.

Explicación:

También se incluyen los equivalentes de 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

La entrada debe ser uno del formato {'abc', 'acb'}.

Python 3 , 78 bytes

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

Pruébalo en línea!

-1 byte gracias al Sr. Xcoder

Pip , 11 bytes

@:_NIgFIPMa

Toma las entradas como argumentos de línea de comandos. Pruébalo en línea!

Explicación

          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

Creo que esta es la única presentación hasta el momento que no utiliza ni una permutación incorporada ni un aleatorio aleatorio / clasificación. Aunque es más largo, creo que el algoritmo es bastante bueno.

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]

Pruébalo en línea!

Explicación

Lo que estamos haciendo es básicamente esto:

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

Aquí hay una prueba de que funciona:

Para una cadena S, defínalo front(S)como el conjunto de cadenas obtenido al elegir un carácter Sy moverlo al frente de S. Por ejemplo, front(ABCDE)es {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Ahora considere una lista de anagramas L, de modo que Lno contenga todos los anagramas posibles (según la descripción del problema). Queremos mostrar que existe una cadena Sen Ltal que front(S)contiene al menos un anagrama S'que no está en L.

Supongamos, por contradicción, que por cada cadena Sde entrada L, cada cadena de entrada front(S)también está en L. Observe que podemos generar una permutación arbitraria de cualquier cadena a través de una serie de movimientos "frontales". Por ejemplo, para obtener

ABCDE -> BAEDC

podemos hacer

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

Asumimos que para cada Sadentro L, cada S'adentro front(S)también está adentro L. Esto también significa que cada S''adentro front(S')está adentro L, y así sucesivamente. Por lo tanto, si Sestá adentro L, cada permutación de Sestá también adentro L. Entonces Ldebe ser un conjunto completo de anagramas, una contradicción.

Por lo tanto, ya tenemos la garantía de que hay al menos una permutación no en L, debe existir una cadena Sde Lde los cuales algunos S'en front(S)que no está en L. QED

El código itera sobre front(S)para cada Sen Ly selecciona una S'que no está en L. Por el resultado anterior, habrá al menos uno S'que califique.

C # (compilador interactivo de 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;}

¡Mis habilidades de golf ciertamente han mejorado desde la primera vez que publiqué esto!

Pruébalo en línea!

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

Encuentre la primera permutación lexicográfica del primer elemento de la matriz que no está contenida en la 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}

Embellecido

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

Prueba

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

Pruébalo en línea!

Scala, 50 bytes

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

Pruébalo en línea!

Explicación

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

Muestre repetidamente las letras de la primera entrada (ya que deberían ser anagramas entre sí) y deténgase cuando una de esas muestras no esté en la lista original.

Casco , 6 bytes

←-⁰P←⁰

Pruébalo en línea!

PHP , 70 bytes

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

Ejecútelo en un servidor web, ingresando 0 valores de indexación o ¡ Pruébelo en línea!

Sin golf

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

no determinista; toma datos de los argumentos de la línea de comandos

Corre con php -r <code>palabras separadas por espacios o pruébalo en línea .

Adjunto , 16 bytes

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

Pruébalo en línea!

Explicación

&\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.@!@#)@{.@:>){.@-.>

La entrada es una lista de cadenas en caja: sentí que era justo así y no declarar las listas de cadenas explícitamente como 4 8 $ 'abcde123', 'ab3e1cd2', '321edbac', 'bcda1e23'.

No me gusta el @ mess en mi código, pero esta vez hay muchos verbos serializados.

Cómo 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

Pruébalo en línea!

05AB1E , 5 bytes

нœIмà

Pruébalo en línea!

Explicación

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

Más o menos la misma respuesta que encontró @ThePirateBay.

JavaScript, 87 bytes

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

Pruébalo en línea!

Esta respuesta se basa (aunque muy modificada) en la respuesta de Imme . Sugirió en un comentario que esta debería ser una respuesta diferente.

El problema con el viejo enfoque es porque sort depende completamente de la implementación. El estándar no garantiza el orden de invocación de la función de clasificación, por lo tanto, en teoría, puede que nunca termine para el primer o el segundo caso de prueba.

Este enfoque es de unos pocos bytes más, pero garantiza que terminará en un tiempo limitado, incluso si Math.randomnunca regresa .5.

CJam , 11 bytes

q~_0=m!\m0=

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Aleatoriza aleatoriamente la primera cadena de la entrada hasta que no sea un elemento de la entrada.

Explicación:

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