Đưa ra một danh sách các chuỗi duy nhất là đảo chữ của nhau, xuất ra đảo chữ của các từ đó khác với mỗi từ trong danh sách.

Các chuỗi sẽ là chữ và số, và được đảm bảo là một đảo chữ hợp lệ.

Chương trình hoặc hàm có thể, nhưng không phải là không xác định, nghĩa là được cung cấp cùng một đầu vào, nhiều mã chạy có thể mang lại các đầu ra khác nhau, miễn là mọi đầu ra có thể là một đầu ra hợp lệ.

Các trường hợp thử nghiệm

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

Hãy thử trực tuyến!

05AB1E , 5 byte

нœ¹мà

Hãy thử trực tuyến!

Giải trình

нœ¹мà

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

Bình thường , 5 byte

h-.ph

Hãy thử trực tuyến!

Giải trình

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

Thạch , 6 byte

XŒ!ḟµḢ

Hãy thử trực tuyến!

Nhiều hơn 1 byte so với câu trả lời 05AB1E và Pyth.

Giải trình:

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.

Tôi đã chọn Xvì đó là cách ngắn nhất mà tôi biết để chọn bất kỳ yếu tố nào từ danh sách mà không thay đổi danh sách ( Ḣvà Ṫkhông hoạt động, ḷ/và ṛ/dài hơn), và nó xảy ra gây ra một số ngẫu nhiên.

Ở µđây khá dư thừa, nhưng không có nó, nó Ḣsẽ được ghép nối với ḟvà nó được hiểu là "lọc ra phần đầu vào", đây không phải là thứ tôi cần ở đây (cái tôi cần là "lọc ra đầu vào, và lấy cái đầu ").

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}

sử dụng một ngẫu nhiên xấu để lặp qua từng hoán vị "ngẫu nhiên".

Có thể chứng minh là sai nhưng afaik ngẫu nhiên xấu chỉ có nghĩa là chúng ta sẽ không nhận được sự ngẫu nhiên thực sự, nhưng vẫn sẽ nhận được mọi hoán vị.

Có vẻ như hoạt động trên tất cả các trường hợp bằng chrome đối với tôi nhưng dường như do hành vi không xác định trong loại lạm dụng này, nó không thể hoạt động trong một số trình duyệt.

(Có lẽ rất vô duyên cảm thấy thoải mái để cải thiện nó trong các giải pháp của riêng bạn)

80 byte

Cảm ơn bình luận của pirateBay - rất nhiều byte

-4 byte nhờ Rick

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

Haskell , 58 byte

-1 byte và một bản sửa lỗi nhờ Laikoni.

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

Hãy thử trực tuyến!

Có lẽ không đáng để nhập khẩu Data.Listcho hoán vị nhưng eh.

Ruby , 46 byte

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

Hãy thử trực tuyến!

Brachylog , 7 byte

hp.¬∈?∧

Hãy thử trực tuyến!

Giải trình

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)

Toán học, 57 byte

không xác định

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

Hãy thử trực tuyến!

Toán học, 56 byte

tính quyết định

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

Hãy thử trực tuyến!

Japt , 7 6 byte

-1 byte nhờ @Shaggy

á kN ö

Hãy thử trực tuyến!

Lấy chuỗi đầu vào là một số đầu vào thay vì như một mảng. Xuất ra một hoán vị ngẫu nhiên; chuyển ösang gđể có được cái đầu tiên thay thế.

Giải trình

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

Hãy thử trực tuyến!

Đã lưu 2 byte nhờ vào Sanchises. setdiff(...,'rows')ngắn hơn phủ định ismember(...,'rows')và nó tránh được một lần trùng lặp. Đã lưu một byte khác nhờ Luis Mendo, bằng cách chuyển sang các ô thay vì mảng.

Giải trình:

Tương đương MATLAB / Octave cũng được bao gồm.

                 % 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

Đầu vào phải là một định dạng {'abc', 'acb'}.

Python 3 , 78 byte

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

Hãy thử trực tuyến!

-1 byte nhờ ông Xcoder

Pip , 11 byte

@:_NIgFIPMa

Lấy đầu vào làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

          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

Tôi tin rằng đây là lần gửi duy nhất cho đến nay không sử dụng phép dựng / hoán vị ngẫu nhiên. Mặc dù nó dài hơn, tôi nghĩ thuật toán này khá gọn gàng.

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]

Hãy thử trực tuyến!

Giải trình

Những gì chúng ta đang làm về cơ bản là thế này:

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

Đây là một bằng chứng cho thấy nó hoạt động:

Đối với một chuỗi S, xác định front(S)là tập hợp các chuỗi có được bằng cách chọn một ký tự từ Svà di chuyển nó đến phía trước S. Ví dụ, front(ABCDE)là {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Bây giờ hãy xem xét một danh sách các đảo chữ cái L, sao cho Lkhông chứa mọi đảo chữ có thể xảy ra (theo mô tả vấn đề). Chúng tôi muốn chứng minh rằng có tồn tại một chuỗi Strong Lđó front(S)có chứa ít nhất một đảo chữ S'không có trong đó L.

Giả sử, bằng cách mâu thuẫn, rằng với mỗi chuỗi Strong L, mọi chuỗi trong front(S)cũng nằm trong L. Quan sát rằng chúng ta có thể tạo ra một hoán vị tùy ý của bất kỳ chuỗi nào thông qua một loạt các động thái "mặt trận". Ví dụ, để có được

ABCDE -> BAEDC

chúng tôi có thể làm

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

Chúng tôi đã giả định rằng đối với mỗi Strong L, mỗi S'trong front(S)cũng là trong L. Điều này cũng có nghĩa là mọi thứ đều S''ở front(S')trong L, v.v. Do đó, nếu Slà trong L, mọi hoán vị của Scũng là trong L. Sau đó Lphải là một bộ đảo chữ hoàn chỉnh, một mâu thuẫn.

Vì vậy, kể từ khi chúng được đảm bảo rằng có ít nhất một hoán vị không trong L, có phải tồn tại một chuỗi Strong Lmà một số S'trong front(S)không có trong L. QED.

Mã lặp đi lặp lại front(S)cho mỗi Strong Lvà chọn một S'cái không có trong L. Theo kết quả trên, sẽ có ít nhất một S'điều kiện đủ điều kiện.

C # (Trình biên dịch tương tác 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;}

Kỹ năng chơi gôn của tôi chắc chắn đã tốt hơn kể từ khi tôi mới đăng bài này!

Hãy thử trực tuyến!

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

Tìm hoán vị từ vựng đầu tiên của phần tử đầu tiên của mảng không có trong mảng.

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}

Làm đẹp

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

Kiểm tra

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

Hãy thử trực tuyến!

Scala, 50 byte

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

Hãy thử trực tuyến!

Giải trình

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

Liên tục lấy mẫu các chữ cái từ mục nhập đầu tiên (vì chúng phải là đảo chữ cái của nhau) và dừng lại khi một trong những mẫu đó không có trong danh sách ban đầu.

Husk , 6 byte

←-⁰P←⁰

Hãy thử trực tuyến!

PHP , 70 byte

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

Chạy trên máy chủ web, nhập 0 giá trị được lập chỉ mục hoặc Thử trực tuyến!

Bị đánh cắp

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

không xác định; lấy đầu vào từ các đối số dòng lệnh

Chạy với php -r <code>follwed bởi các từ tách biệt không gian hoặc thử trực tuyến .

Tùy viên , 16 byte

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

Hãy thử trực tuyến!

Giải trình

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

Lựa chọn thay thế

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

Đầu vào là một danh sách các chuỗi được đóng hộp - Tôi cảm thấy nó công bằng như thế này và không khai báo danh sách các chuỗi rõ ràng là 4 8 $ 'abcde123', 'ab3e1cd2', '321edbac', 'bcda1e23'.

Tôi không thích mớ hỗn độn @ trong mã của mình, nhưng có rất nhiều động từ nối tiếp lần này.

Làm thế nào nó hoạt động:

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

Hãy thử trực tuyến!

05AB1E , 5 byte

нœIмà

Hãy thử trực tuyến!

Giải trình

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

Khá nhiều câu trả lời tương tự mà @ThePirateBay tìm thấy.

JavaScript, 87 byte

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

Hãy thử trực tuyến!

Câu trả lời này dựa trên (mặc dù đã được sửa đổi nhiều) dựa trên câu trả lời của Imme . Ông đề nghị trong một bình luận rằng đây nên là một câu trả lời khác.

Vấn đề với cách tiếp cận cũ là vì sorthoàn toàn phụ thuộc vào việc thực hiện. Tiêu chuẩn không đảm bảo thứ tự gọi hàm sắp xếp, do đó về mặt lý thuyết, nó có thể không bao giờ kết thúc cho trường hợp thử nghiệm thứ nhất hoặc thứ hai.

Cách tiếp cận này dài hơn vài byte, nhưng nó đảm bảo rằng nó sẽ kết thúc trong thời gian bị ràng buộc, ngay cả khi Math.randomkhông bao giờ quay trở lại .5.

CJam , 11 byte

q~_0=m!\m0=

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

Ngẫu nhiên xáo trộn chuỗi đầu tiên của đầu vào cho đến khi nó không phải là một yếu tố của đầu vào.

Giải trình:

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