ให้รายการของสตริงที่ไม่ซ้ำกันซึ่งเป็นแอนนาแกรมของแต่ละรายการให้ส่งออกแอนนาแกรมของคำเหล่านั้นที่แตกต่างจากแต่ละคำในรายการ

สตริงจะเป็นตัวอักษรและตัวเลขและรับประกันว่าจะเป็นแอนนาแกรมที่ถูกต้อง

โปรแกรมหรือฟังก์ชั่นสามารถทำได้ แต่ไม่จำเป็นต้องเป็นแบบไม่กำหนดค่าความหมายที่กำหนดให้กับอินพุตเดียวกันการรันโค้ดหลาย ๆ ตัวสามารถสร้างเอาต์พุตที่แตกต่างกันได้ตราบใดที่เอาต์พุตที่เป็นไปได้ทั้งหมด

กรณีทดสอบ

[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 ตัวสุ่มที่ไม่ดีก็หมายความว่าเราจะไม่ได้รับการสุ่มที่แท้จริง แต่จะยังคงได้รับการเปลี่ยนแปลงทุกครั้ง

ดูเหมือนว่าจะทำงานกับทุกกรณีใน Chrome สำหรับฉัน แต่เห็นได้ชัดว่าเนื่องจากพฤติกรรมที่ไม่ได้กำหนดในการละเมิดประเภทนี้มันไม่สามารถทำงานได้ในเบราว์เซอร์บางตัว

(อาจรู้สึกไม่ดีมากที่จะปรับปรุงในโซลูชันของคุณเอง)

80 ไบต์

ขอบคุณ pirateBay แสดงความคิดเห็น - เป็นจำนวนมากไบต์

-4 ไบต์ต้องขอบคุณ Rick

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

Haskell , 58 ไบต์

-1 ไบต์และการแก้ไขต้องขอบคุณ Laikoni

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

ลองออนไลน์!

Brachylogขนาด 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)

Mathematica, 57 ไบต์

ไม่ใช่กำหนด

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

ลองออนไลน์!

Mathematica, 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')และหลีกเลี่ยงการทำซ้ำหนึ่งรายการ บันทึกอีกไบต์ด้วยการขอบคุณ Luis Mendo โดยเปลี่ยนไปใช้เซลล์แทนอาร์เรย์

คำอธิบาย:

MATLAB / คู่เทียบเท่าจะรวมอยู่ด้วย

                 % 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'}การป้อนข้อมูลต้องเป็นหนึ่งในรูปแบบ

Python 3 , 78 ไบต์

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

ลองออนไลน์!

-1 ไบต์ขอบคุณ Mr. Xcoder

Pip 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สังเกตว่าเราสามารถสร้างการเรียงสับเปลี่ยนโดยพลการของสตริงใด ๆ ผ่านชุดของการเคลื่อนไหว "fronting" ตัวอย่างเช่นที่จะได้รับ

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

รหัส iterates กว่าfront(S)สำหรับแต่ละSในLและจะเลือกที่ไม่ได้อยู่ในS' Lจากผลลัพธ์ข้างต้นจะS'มีคุณสมบัติอย่างน้อยหนึ่งรายการที่มีคุณสมบัติ

C # (Visual C # Interactive คอมไพเลอร์) , 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

ค้นหาการเปลี่ยนแปลงทางคำศัพท์แรกขององค์ประกอบแรกของอาร์เรย์ที่ไม่มีอยู่ในอาร์เรย์

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

ลองออนไลน์!

สกาลา, 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

สุ่มตัวอย่างจดหมายซ้ำจากรายการแรก (เพราะควรเป็นแอนนาแกรมของกันและกัน) และหยุดเมื่อหนึ่งในตัวอย่างเหล่านั้นไม่ได้อยู่ในรายการเดิม

Husk , 6 ไบต์

←-⁰P←⁰

ลองออนไลน์!

PHP , 70 ไบต์

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

ทำงานบนเว็บเซิร์ฟเวอร์โดยป้อน 0 รับค่าดัชนีหรือลองออนไลน์!

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 ไบต์

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

ไม่ใช่กำหนด; รับอินพุตจากอาร์กิวเมนต์บรรทัดรับคำสั่ง

ทำงานกับphp -r <code>follwed ด้วยช่องว่างคำแยกหรือลองออนไลน์

ทูตขนาด 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'

ฉันไม่ชอบ @ ระเบียบในรหัสของฉัน แต่มีคำกริยาต่อเนื่องจำนวนมากในเวลานี้

มันทำงานอย่างไร:

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

ลองออนไลน์!

คำตอบนี้เป็นไปตาม (ถึงแม้จะมีการปรับเปลี่ยนอย่างมาก) ในคำตอบของ imme เขาแนะนำในความคิดเห็นว่านี่ควรเป็นคำตอบที่ต่างออกไป

ปัญหาเกี่ยวกับวิธีการแบบเก่านั้นเป็นเพราะ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