¡Emite un anagrama! ¡No, no ese!

28

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
Levemente Milquetoast
fuente

Respuestas:

20

Python 3 , 64 bytes

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

Pruébalo en línea!

Sr. Xcoder
fuente
44
¿Pero itertoolsalguna vez es la respuesta?
MildlyMilquetoast
@MistahFiggins Nominado
Sr. Xcoder
@ Mr.Xcoder antes del 22 de julio de 2015
Stan Strum
@StanStrum Lo acabo de mencionar, soy consciente de esa restricción. Como dijo Stewie ...
Sr. Xcoder
1
@ jpmc26 Sí, de esta manera puede colocar f=\el encabezado Probar en línea y dejar la función en el anonimato, sin afectar el contador automático de bytes de TiO
Sr. Xcoder
9

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)

fuente
7

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.
notjagan
fuente
4

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 ").

usuario202729
fuente
4

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)')
Imme
fuente
Las funciones de flecha FYI están permitidas (por ejemplo, en a=>blugar de function(a){return b}). Ahorra muchos bytes.
Wow ... eso ahorrará bastantes bytes.
Imme
s.split("")puede ser [...s]. También join("")puede ser `join```
Rick Hitchcock
@ThePirateBay temía que ese fuera el caso, pero ¿por qué es eso? (Soy consciente de que la clasificación no es completamente aleatoria, pero todas las secuencias DEBEN ser posibles)
Imme
@Imme. Aquí hay una versión de trabajo de 87 bytes . Tenga en cuenta que su sortfunción nunca regresa 0(o al menos extremadamente rara), por eso no funcionó.
4

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.

totalmente humano
fuente
1
Puede guardar un byte con notElem. Me sorprendería si alguien encuentra una función de permutación que supera la importación, mi enfoque más corto es de 60 bytes frente a los 29 bytes de la importación.
Laikoni
1
Aquí hay una función de permutación de 43 bytes, pero solo para listas libres duplicadas.
Laikoni
1
Además, su solución actualmente no funciona porque $falta antes l!!0.
Laikoni
3

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)
Fatalizar
fuente
3

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!

J42161217
fuente
3

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
Justin Mariner
fuente
Nueces, me ganaste. Puede tomar la entrada como cadenas individuales y guardar un byte con á kN ö.
Shaggy
@ Shaggy Esa es una excelente manera de obtener el primer elemento de entrada, tendré que recordar eso. ¡Gracias!
Justin Mariner el
2

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'}.

Stewie Griffin
fuente
2

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

Hiperneutrino
fuente
if x not in aes if~-(x in a)para 178
Sr. Xcoder
@ Mr.Xcoder. ¿Quieres decir 78verdad?
@ThePirateBay Sí, lo hago ... ¡Vaya!
Sr. Xcoder
1
¿Qué tal 66 bytes ?
NieDzejkob
1
@NieDzejkob Eso es impresionantemente más corto. Deberías publicar el tuyo si quieres
HyperNeutrino
2

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
DLosc
fuente
2

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.

DLosc
fuente
1

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.

Neil
fuente
1

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")))
}
jrtapsell
fuente
1

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!

Steadybox
fuente
1

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
Karl Bielefeldt
fuente
1

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.

Andrew Haynes
fuente
82 bytes
Giuseppe
1

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;
SmartCoder
fuente
Guarde dos bytes con en do{...}while($j);lugar de $j=1;while($j){...}. Utilice la definición en el lugar para $gdeshacerse de las llaves (y guardar cuatro bytes).
Titus
1

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 .

Titus
fuente
1

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

Conor O'Brien
fuente
0

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!

Galen Ivanov
fuente
1
Tomando de entrada como una tabla, por 21 bytes: {.@(-.~i.@!@#@{.A.{.). Pruébalo en línea!
Jonás
0

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.

Cinari
fuente
0

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.


fuente
0

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"
Fruta Esolanging
fuente
Creo que puede haber un error tipográfico en su explicación: la respuesta que da su código es diferente de lo que dice su explicación
MildlyMilquetoast
0

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
Jo King
fuente