Dato un elenco di stringhe uniche che sono anagrammi l'uno dell'altro, genera un anagramma di quelle parole che è diverso da ogni parola nell'elenco.

Le stringhe saranno alfanumeriche e sarà garantito un anagramma valido.

Il programma o la funzione possono, ma non devono essere non deterministici, nel senso che dato lo stesso input, l'esecuzione multipla di un codice può produrre output diversi, purché ogni output possibile sia valido.

Casi test

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

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

Provalo online!

05AB1E , 5 byte

нœ¹мà

Provalo online!

Spiegazione

нœ¹мà

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

h-.ph

Provalo online!

Spiegazione

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

Gelatina , 6 byte

XŒ!ḟµḢ

Provalo online!

1 byte in più rispetto allo 05AB1E e alla risposta Pyth.

Spiegazione:

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.

Ho scelto Xperché è il modo più breve che conosco per selezionare qualsiasi elemento dall'elenco senza alterare l'elenco ( Ḣe Ṫnon funziona, ḷ/eṛ/ è più lungo), e sembra causare casualità.

Il µqui è piuttosto ridondante, ma senza di esso, Ḣsarebbe accoppiato con il ḟ, ed è interpretato come "filtrare la testa dell'input", che non è ciò di cui ho bisogno qui (ciò di cui ho bisogno è "filtrare l'input, e prendi la testa ").

Javascript, 118 byte

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

usa un cattivo randomizzatore per scorrere su ogni permutazione "casuale".

Probabilmente dimostrabilmente sbagliato ma afaik il cattivo randomizzatore significa solo che non avremo una vera casualità, ma otterremo comunque ogni permutazione.

Sembra funzionare su tutti i casi in Chrome per me, ma apparentemente a causa di comportamenti indefiniti in questo tipo di abuso, non può funzionare in alcuni browser.

(Probabilmente molto non golfato sentiti libero di migliorarlo nelle tue soluzioni)

80 byte

Grazie al commento di pirateBay - molti byte

-4 byte grazie a Rick

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

Haskell , 58 byte

-1 byte e una correzione grazie a Laikoni.

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

Provalo online!

Probabilmente non vale la pena importare Data.Listper permutazioni ma eh.

Rubino , 46 byte

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

Provalo online!

Brachylog , 7 byte

hp.¬∈?∧

Provalo online!

Spiegazione

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 byte

non deterministico

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

Provalo online!

Mathematica, 56 byte

deterministico

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

Provalo online!

Japt , 7 6 byte

-1 byte grazie a @Shaggy

á kN ö

Provalo online!

Accetta le stringhe di input come più input anziché come array. Emette una permutazione casuale; passare öa gper ottenere invece il primo.

Spiegazione

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

1X)Y@Z{GX-1)

Provalo online!

Salvato 2 byte grazie a Sanchises. setdiff(...,'rows')è più corto di negare ismember(...,'rows')ed evita una duplicazione. Salvataggio di un altro byte grazie a Luis Mendo, passando alle celle anziché alle matrici.

Spiegazione:

Sono inclusi anche gli equivalenti 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

L'input deve essere uno nel formato {'abc', 'acb'}.

Python 3 , 78 byte

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

Provalo online!

-1 byte grazie a Mr. Xcoder

Pip , 11 byte

@:_NIgFIPMa

Prende gli input come argomenti della riga di comando. Provalo online!

Spiegazione

          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 byte

Credo che questa sia l' unica presentazione finora che non utilizza né una incorporazione di permutazione né uno shuffle / sort casuale. Anche se è più lungo, penso che l'algoritmo sia piuttosto pulito.

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]

Provalo online!

Spiegazione

Quello che stiamo facendo è sostanzialmente questo:

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

Ecco una prova che funziona:

Per una stringa S, definisci front(S)come l'insieme di stringhe ottenuto scegliendo un carattere Se spostandolo in primo piano S. Ad esempio, lo front(ABCDE)è {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Ora considera un elenco di anagrammi L, tale cheL non contenga tutti i possibili anagrammi (come da descrizione del problema). Vogliamo dimostrare che esiste una stringa Sin Ltale che front(S)contiene almeno un anagramma S'che non è in L.

Supponiamo, a titolo di contraddizione, che per ogni stringa S dentro L, anche ogni stringa dentro front(S)sia dentro L. Osserva che possiamo generare una permutazione arbitraria di qualsiasi stringa tramite una serie di mosse di "fronting". Ad esempio, per ottenere

ABCDE -> BAEDC

possiamo fare

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

Abbiamo ipotizzato che per ogni Sin L, anche ogni S'in front(S)sia presente L. Questo significa anche che ogni S''dentro front(S')è dentro Le così via. Pertanto, se Sè inL , ogni permutazione di Sè anche in L. Quindi Ldeve essere un set completo di anagrammi, una contraddizione.

Quindi, dal momento che abbiamo la garanzia che almeno una permutazione non c'è non è in L, deve esistere una stringa Sin Lper il quale alcuniS' in front(S)non è in L. QED.

Il codice scorre ripetutamente front(S)per ogni Sin Le seleziona un S'che non è in L. Con il risultato sopra, ce ne sarà almeno uno S'che si qualifica.

C # (compilatore interattivo Visual C #) , 116 96 byte

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

Le mie abilità nel golf sono sicuramente migliorate da quando l'ho pubblicato per la prima volta!

Provalo online!

JavaScript (ES7), 172 byte

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

Trova la prima permutazione lessicografica del primo elemento dell'array che non è contenuto nell'array.

Kotlin , 104 byte

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

Abbellire

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

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

Provalo online!

Scala, 50 byte

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

Provalo online!

Spiegazione

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 byte

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

Campionate ripetutamente le lettere della prima voce (poiché dovrebbero essere anagrammi l'una dell'altra) e fermatevi quando uno di quei campioni non è nell'elenco originale.

Buccia , 6 byte

←-⁰P←⁰

Provalo online!

PHP , 70 byte

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

Esegui su un server web, immettendo 0 valori di indicizzazione o provalo 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 byte

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

non deterministico; accetta input dagli argomenti della riga di comando

Corri con le php -r <code>parole separate dallo spazio o provalo online .

Attache , 16 byte

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

Provalo online!

Spiegazione

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

alternative

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

J , 25 byte

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

L'input è un elenco di stringhe inscatolate - mi è sembrato giusto così e non dichiarare esplicitamente gli elenchi di stringhe come 4 8 $ 'abcde123', 'ab3e1cd2', '321edbac', 'bcda1e23'.

Non mi piace il pasticcio @ nel mio codice, ma questa volta ci sono molti verbi serializzati.

Come funziona:

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

Provalo online!

05AB1E , 5 byte

нœIмà

Provalo online!

Spiegazione

нœ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 la stessa risposta che ha trovato @ThePirateBay.

JavaScript, 87 byte

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

Provalo online!

Questa risposta si basa (sebbene fortemente modificata) sulla risposta di Imme . Ha suggerito in un commento che questa dovrebbe essere una risposta diversa.

Il problema con il vecchio approccio è perché sort dipende completamente dall'implementazione. Lo standard non garantisce l'ordine di chiamata della funzione di ordinamento, quindi teoricamente potrebbe non finire mai per il primo o il secondo caso di test.

Questo approccio è più lungo di pochi byte, ma garantisce che finirà in tempo limitato, anche se Math.randomnon ritorna mai .5.

CJam , 11 byte

q~_0=m!\m0=

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Mescola casualmente la prima stringa dell'input fino a quando non è un elemento dell'input.

Spiegazione:

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