Étant donné une liste de chaînes uniques qui sont des anagrammes les unes des autres, affichez une anagramme de ces mots qui est différente de chaque mot de la liste.

Les chaînes seront alphanumériques et il est garanti qu'il y aura une anagramme valide.

Le programme ou la fonction peut, mais ne doit pas être non déterministe, ce qui signifie que pour la même entrée, plusieurs exécutions de code peuvent produire des sorties différentes, tant que chaque sortie possible est valide.

Cas de 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 octets

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

Essayez-le en ligne!

05AB1E , 5 octets

нœ¹мà

Essayez-le en ligne!

Explication

нœ¹мà

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

h-.ph

Essayez-le en ligne!

Explication

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

Gelée , 6 octets

XŒ!ḟµḢ

Essayez-le en ligne!

1 octet de plus que le 05AB1E et la réponse Pyth.

Explication:

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.

J'ai choisi Xparce que c'est la façon la plus courte que je connaisse de choisir n'importe quel élément de la liste sans modifier la liste ( Ḣet Ṫcela ne fonctionne pas, ḷ/et ṛ/c'est plus long), et il se trouve que cela cause un certain caractère aléatoire.

L' µici est assez redondant, mais sans lui, le Ḣserait couplé avec le ḟ, et il est interprété comme "filtrer la tête de l'entrée", ce qui n'est pas ce dont j'ai besoin ici (ce dont j'ai besoin est "filtrer l'entrée, et prenez la tête ").

Javascript, 118 octets

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

utilise un mauvais randomiseur pour itérer sur chaque permutation "aléatoire".

Probablement peut-être faux, mais afaik le mauvais randomiseur signifie simplement que nous n'obtiendrons pas le vrai hasard, mais nous obtiendrons toujours chaque permutation.

Semble fonctionner sur tous les cas dans Chrome pour moi, mais apparemment en raison d'un comportement indéfini dans ce type d'abus, il ne peut pas fonctionner dans certains navigateurs.

(Probablement très non golfé, n'hésitez pas à l'améliorer dans vos propres solutions)

80 octets

Merci au commentaire de pirateBay - beaucoup d'octets

-4 octets grâce à Rick

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

Haskell , 58 octets

-1 octet et un correctif grâce à Laikoni.

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

Essayez-le en ligne!

Ça ne vaut probablement pas la peine d'être importé Data.Listpour des permutations mais hein.

Rubis , 46 octets

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

Essayez-le en ligne!

Brachylog , 7 octets

hp.¬∈?∧

Essayez-le en ligne!

Explication

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 octets

non déterministe

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

Essayez-le en ligne!

Mathematica, 56 octets

déterministe

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

Essayez-le en ligne!

Japt , 7 6 octets

-1 octet grâce à @Shaggy

á kN ö

Essayez-le en ligne!

Prend les chaînes d'entrée comme plusieurs entrées au lieu d'un tableau. Génère une permutation aléatoire; passez öà la place gpour obtenir le premier.

Explication

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

1X)Y@Z{GX-1)

Essayez-le en ligne!

Sauvegardé 2 octets grâce à Sanchises. setdiff(...,'rows')est plus court que la négation ismember(...,'rows')et évite une duplication. Un autre octet enregistré grâce à Luis Mendo, en passant aux cellules au lieu des tableaux.

Explication:

Les équivalents MATLAB / Octave sont également inclus.

                 % 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'entrée doit être un format {'abc', 'acb'}.

Python 3 , 78 octets

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

Essayez-le en ligne!

-1 octet merci à M. Xcoder

Pip , 11 octets

@:_NIgFIPMa

Prend les entrées comme arguments de ligne de commande. Essayez-le en ligne!

Explication

          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 octets

Je crois que c'est la seule soumission jusqu'à présent qui n'utilise ni une permutation intégrée ni un mélange aléatoire / tri. Même s'il est plus long, je pense que l'algorithme est assez soigné.

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]

Essayez-le en ligne!

Explication

Ce que nous faisons est essentiellement le suivant:

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

Voici une preuve que cela fonctionne:

Pour une chaîne S, définissez front(S)comme l'ensemble de chaînes obtenu en choisissant un caractère Set en le déplaçant vers l'avant S. Par exemple, front(ABCDE)est {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Considérons maintenant une liste d'anagrammes L, telle qu'elle Lne contient pas toutes les anagrammes possibles (selon la description du problème). Nous souhaitons montrer qu'il existe une chaîne Sen Ltel qui front(S)contient au moins une anagramme S'qui n'est pas en L.

Supposons, à titre de contradiction, que pour chaque chaîne Sdans L, chaque chaîne dans front(S)soit également dans L. Observez que nous pouvons générer une permutation arbitraire de n'importe quelle chaîne via une série de mouvements de "fronting". Par exemple, pour obtenir

ABCDE -> BAEDC

nous pouvons faire

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

Nous avons supposé que pour chaque Sentrée L, chaque S'entrée front(S)est également présente L. Cela signifie également que chaque S''entrée front(S')est dans Let ainsi de suite. Par conséquent, si Sest dans L, chaque permutation de l' Sest également L. Il Lfaut alors un ensemble complet d'anagrammes, une contradiction.

Donc, puisque nous sommes assurés qu'il y ait au moins une permutation pas dans L, il doit exister une chaîne Sen Ldont certains S'en front(S)est pas L. QED.

Le code itère sur front(S)chaque Sdans Let sélectionne un S'qui ne soit pas L. Par le résultat ci-dessus, il y en aura au moins un S'qui se qualifie.

C # (Visual C # Interactive Compiler) , 116 96 octets

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

Mes compétences en golf se sont certainement améliorées depuis la première fois que j'ai posté ça!

Essayez-le en ligne!

JavaScript (ES7), 172 octets

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

Trouvez la première permutation lexicographique du premier élément du tableau qui n'est pas contenu dans le tableau.

Kotlin , 104 octets

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

Embellie

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

Tester

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 octets

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

Essayez-le en ligne!

Scala, 50 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Échantillonnez à plusieurs reprises les lettres de la première entrée (car elles devraient être des anagrammes les unes des autres) et arrêtez lorsque l'un de ces échantillons ne figure pas dans la liste d'origine.

Husk , 6 octets

←-⁰P←⁰

Essayez-le en ligne!

PHP , 70 octets

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

Exécutez sur un serveur Web, saisissez 0 valeurs indexées ou essayez-le en ligne!

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

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

non déterministe; prend l'entrée des arguments de ligne de commande

Exécutez avec php -r <code>des mots séparés par des espaces ou essayez-le en ligne .

Attaché , 16 octets

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

Essayez-le en ligne!

Explication

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

Alternatives

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

J , 25 octets

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

L'entrée est une liste de chaînes encadrées - je pensais que c'était juste comme ça et de ne pas déclarer les listes de chaînes explicitement comme 4 8 $ 'abcde123', 'ab3e1cd2', '321edbac', 'bcda1e23'.

Je n'aime pas le @ mess dans mon code, mais il y a beaucoup de verbes sérialisés cette fois.

Comment ça marche:

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

Essayez-le en ligne!

05AB1E , 5 octets

нœIмà

Essayez-le en ligne!

Explication

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

À peu près la même réponse que @ThePirateBay a trouvée.

JavaScript, 87 octets

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

Essayez-le en ligne!

Cette réponse est basée (bien que fortement modifiée) sur la réponse d'Imme . Il a suggéré dans un commentaire que cela devrait être une réponse différente.

Le problème avec l'ancienne approche est parce que cela sortdépend complètement de l'implémentation. La norme ne garantit pas l'ordre d'appel de la fonction de tri, par conséquent, elle ne peut théoriquement jamais se terminer pour le premier ou le deuxième cas de test.

Cette approche prend quelques octets de plus, mais elle garantit qu'elle se terminera dans un temps limité, même si elle Math.randomne revient jamais .5.

CJam , 11 octets

q~_0=m!\m0=

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Mélange aléatoirement la première chaîne de l'entrée jusqu'à ce qu'elle ne soit pas un élément de l'entrée.

Explication:

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