Давши список унікальних рядків, які є анаграмами один одного, виведіть анаграму тих слів, яка відрізняється від кожного слова у списку.

Рядки будуть буквено-цифровими, і гарантовано буде дійсна анаграма.

Програма або функція можуть, але не повинні бути недетермінованими, тобто з огляду на один і той же вхід, багаторазове виконання коду може отримати різні результати, доки кожен можливий вихід є дійсним.

Випробування

[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 байти

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

Спробуйте в Інтернеті!

05AB1E , 5 байт

нœ¹мà

Спробуйте в Інтернеті!

Пояснення

нœ¹мà

н     // 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 байт

h-.ph

Спробуйте в Інтернеті!

Пояснення

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

Желе , 6 байт

XŒ!ḟµḢ

Спробуйте в Інтернеті!

На 1 байт більше, ніж 05AB1E та відповідь Pyth.

Пояснення:

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.

Я вибрав, Xтому що це найкоротший шлях, який я знаю, щоб вибрати будь-який елемент зі списку, не змінюючи список ( Ḣі Ṫне працює, ḷ/і ṛ/довший), і це може спричинити деяку випадковість.

µТут досить зайвими, але без нього, Ḣбуде працювати в парі з ḟ, і це інтерпретується як «фільтр з головки введення», який не те , що треба тут (що мені потрібно «відфільтрувати вхід, і дістань голову ").

Javascript, 118 байт

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

використовує поганий рандомизатор для ітерації над кожною "випадковою" перестановкою.

Можливо, помилково помилково, але afaik поганий рандомізатор просто означає, що ми не будемо отримувати справжню випадковість, але все одно отримаємо кожну перестановку.

Здається, працює над усіма випадками хромування для мене, але, мабуть, через невизначеність поведінки при подібному зловживанні він не може працювати в деяких браузерах.

(Напевно, дуже неозорені сміливо вдосконалюєте це у власних рішеннях)

80 байт

Завдяки коментарю pirateBay - багато байтів

-4 байти завдяки Ріку

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

Хаскелл , 58 байт

-1 байт і виправлення завдяки Лайконі.

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

Спробуйте в Інтернеті!

Напевно, не варто імпортувати Data.Listдля перестановок, але так.

Рубін , 46 байт

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

Спробуйте в Інтернеті!

Брахілог , 7 байт

hp.¬∈?∧

Спробуйте в Інтернеті!

Пояснення

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)

Математика, 57 байт

недетерміновані

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

Спробуйте в Інтернеті!

Математика, 56 байт

детермінований

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

Спробуйте в Інтернеті!

Japt , 7 6 байт

-1 байт завдяки @Shaggy

á kN ö

Спробуйте в Інтернеті!

Приймає рядки введення як декілька входів замість масиву. Виводить випадкову перестановку; перейти öна, gщоб отримати перший замість цього.

Пояснення

á 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 байт

1X)Y@Z{GX-1)

Спробуйте в Інтернеті!

Збережено 2 байти завдяки Sanchises. setdiff(...,'rows')коротше, ніж заперечення, ismember(...,'rows')і це дозволяє уникнути одного дублювання. Збережено ще один байт завдяки Луїсу Мендо, перейшовши на комірки замість масивів.

Пояснення:

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

Вхід повинен бути одним форматом {'abc', 'acb'}.

Пітон 3 , 78 байт

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

Спробуйте в Інтернеті!

-1 байт завдяки спадару Xcoder

Піп , 11 байт

@:_NIgFIPMa

Приймає дані як аргументи командного рядка. Спробуйте в Інтернеті!

Пояснення

          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 байт

Я вважаю, що це єдине досі подання, яке не використовує ні перестановку, вбудовану, ні випадкове переміщення / сортування. Незважаючи на те, що він довший, я думаю, що алгоритм досить акуратний.

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]

Спробуйте в Інтернеті!

Пояснення

Ми робимо в основному це:

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

Ось доказ того, що це працює:

Для рядка Sвизначте front(S)набір рядків, отриманих шляхом вибору одного символу Sта переміщення його на передню частину S. Наприклад, front(ABCDE)є {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Тепер розглянемо список анаграм L, що Lне містить усіх можливих анаграм (відповідно до опису проблеми). Ми хочемо показати, що існує рядок Sу Lтакому, який front(S)містить принаймні одну анаграму S', якої немає L.

Припустимо, від супротивного, що для кожного рядка Sв L, кожен рядок в front(S)також в L. Зауважте, що ми можемо генерувати довільну перестановку будь-якого рядка за допомогою серії "фронтальних" рухів. Наприклад, дістати

ABCDE -> BAEDC

ми можемо зробити

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

Ми припустили, що для кожного Sв L, також кожен S'ін front(S)є L. Це також означає, що кожен S''ін front(S')є L, і так далі. Тому, якщо Sє L, кожна перестановка Sтакож є в L. Тоді Lповинен бути повний набір анаграм, суперечність.

Таким чином, оскільки ми гарантували , що існує принаймні одна перестановка НЕ в L, повинна існувати рядок Sв Lпротягом яких деякі S'в front(S)це не L. QED.

Код повторюється front(S)для кожного Sв Lі вибирає номер, S'який не знаходиться в L. За вищенаведеним результатом буде щонайменше один, S'який кваліфікується.

C # (Visual C # Interactive Compiler) , 116 96 байт

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

Мої навички гольфу, безумовно, покращилися з тих пір, коли я вперше опублікував це!

Спробуйте в Інтернеті!

JavaScript (ES7), 172 байти

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

Знайдіть першу лексикографічну перестановку першого елемента масиву, який не міститься в масиві.

Котлін , 104 байти

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

Прикрасили

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

Тест

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 байт

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

Спробуйте в Інтернеті!

Scala, 50 байт

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

Спробуйте в Інтернеті!

Пояснення

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 байт

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

Неодноразово відбирайте букви з першого запису (так як вони повинні бути анаграмами один одного) і зупиняйтеся, коли одного з цих зразків немає у первинному списку.

Лушпиння , 6 байт

←-⁰P←⁰

Спробуйте в Інтернеті!

PHP , 70 байт

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

Запустіть на веб-сервері, ввівши 0 індексованих значень отримати або спробуйте в Інтернеті!

Безумовно

$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 байт

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

недетерміновані; приймає дані з аргументів командного рядка

Запустіть php -r <code>слова, розділені пробілом, або спробуйте в Інтернеті .

Attache , 16 байт

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

Спробуйте в Інтернеті!

Пояснення

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

Альтернативи

17 байт :{&\S! !S@_[0]Ø_}

18 байт :{&\S! !Id@_[0]Ø_}

19 байт :{&\S!(!Id)@_[0]Ø_}

26 байт :{&\S!Permutations@_[0]Ø_}

26 байт :{&\S!Permutations[_@0]Ø_}

26 байт :{(Permutations[_@0]Ø_)@0}

26 байт :&\S##~`Ø#Permutations@&\S

27 байт :Last@{Permutations[_@0]Ø_}

27 байт :`@&0@{Permutations[_@0]Ø_}

28 байт :Last##~`Ø#Permutations@&{_}

28 байт :Last##~`Ø#Permutations@Last

28 байт :First@{Permutations[_@0]Ø_}

30 байт :{NestWhile[Shuffle,`in&_,_@0]}

33 байти :{If[(q.=Shuffle[_@0])in _,$@_,q]}

33 байти :{q.=Shuffle[_@0]If[q in _,$@_,q]}

34 байти :{If[Has[_,q.=Shuffle[_@0]],$@_,q]}

J , 25 байт

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

Вхід є списком рядків у вікні - я вважав, що це справедливо, і не оголошувати списки рядків явно як 4 8 $ 'abcde123', 'ab3e1cd2', '321edbac', 'bcda1e23'.

Мені не подобається @ mess у моєму коді, але цього разу є багато серіалізованих дієслів.

Як це працює:

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

Спробуйте в Інтернеті!

05AB1E , 5 байт

нœIмà

Спробуйте в Інтернеті!

Пояснення

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

Приблизно така ж відповідь, яку знайшов @ThePirateBay.

JavaScript, 87 байт

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

Спробуйте в Інтернеті!

Ця відповідь заснована (хоча і сильно модифікована) на відповіді Імме . У коментарі він запропонував, що це має бути інша відповідь.

Проблема старого підходу полягає в тому, що sortвін повністю залежить від реалізації. Стандарт не гарантує порядок виклику функції сортування, тому теоретично він ніколи не може закінчитися для першого або другого тестового випадку.

Цей підхід на кілька байт довший, але він гарантує, що він закінчиться у обмежений час, навіть якщо Math.randomніколи не повернеться .5.

CJam , 11 байт

q~_0=m!\m0=

Спробуйте в Інтернеті!

Пояснення

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 байти

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

Спробуйте в Інтернеті!

Випадково перетасовує перший рядок входу, поки він не є елементом введення.

Пояснення:

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