Birbirlerinin anagramları olan benzersiz dizelerin bir listesi göz önüne alındığında, listedeki her kelimeden farklı olan kelimelerin bir anagramını gösterir.

Dizeler alfanümerik olacaktır ve geçerli bir anagram olduğu garantilidir.

Program veya işlev belirleyici olabilir, ancak belirleyici olmak zorunda değildir, yani aynı girdi verildiğinde, kodun birden fazla çalıştırılması, her olası çıktı geçerli olduğu sürece farklı çıktılar verebilir.

Test Kılıfları

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

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

Çevrimiçi deneyin!

05AB1E , 5 bayt

нœ¹мà

Çevrimiçi deneyin!

açıklama

нœ¹мà

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

h-.ph

Çevrimiçi deneyin!

açıklama

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

Jöle , 6 bayt

XŒ!ḟµḢ

Çevrimiçi deneyin!

1 byte, 05AB1E ve Pyth cevabından daha fazla.

Açıklama:

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.

Seçtim Xçünkü listeden herhangi bir elementi listeyi değiştirmeden seçmek en kısa yoldu ( Ḣve Ṫişe yaramadı,ḷ/ ve ṛ/daha uzun) ve bazı rastlantısallıklara neden oluyor.

µBurada oldukça gereksiz olduğunu, ancak o olmadan Ḣile eşleştirilmiş olacağını ḟve ne ben burada gerekmez değil "girdi başkanı dışarı filtre" olarak yorumlanır (ihtiyacım olanı girişi dışında "filtredir, ve kafa al ").

Javascript, 118 Bayt

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

Her "rastgele" permütasyon üzerinde yineleme yapmak için kötü bir randomizer kullanır.

Muhtemelen kesinlikle yanlış ama kötü randomizer afaik sadece gerçek rastgelelik alamayacağımız anlamına gelir, ama yine de her permütasyon alacaktır.

Benim için tüm chrome'daki vakalar üzerinde çalışıyor gibi görünüyor ama görünüşe göre bu türden kötüye kullanımdaki tanımsız davranış nedeniyle, bazı tarayıcılarda çalışamıyor.

(Muhtemelen çok unungolfed kendi çözümlerinde geliştirmek için çekinmeyin)

80 bayt

PirateBay'in yorumu - bir sürü bayt

Rick sayesinde -4 bayt

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

Haskell , 58 bayt

Laikoni sayesinde -1 bayt ve bir düzeltme.

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

Çevrimiçi deneyin!

Muhtemelen Data.Listpermütasyonlar için ithal etmeye değmez ama ha.

Ruby , 46 bayt

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

Çevrimiçi deneyin!

Brachylog , 7 bayt

hp.¬∈?∧

Çevrimiçi deneyin!

açıklama

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 bayt

belirli olmayan

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

Çevrimiçi deneyin!

Mathematica, 56 bayt

deterministik

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

Çevrimiçi deneyin!

Japt , 7 6 bayt

@Shaggy sayesinde -1 bayt

á kN ö

Çevrimiçi deneyin!

Giriş dizelerini bir dizi yerine birkaç giriş olarak alır. Rasgele bir permütasyon üretir; Bunun yerine ilkini almak için geçiş öyapın g.

açıklama

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

1X)Y@Z{GX-1)

Çevrimiçi deneyin!

Sanchises sayesinde 2 bayt kaydedildi. setdiff(...,'rows')olumsuzlamaktan daha kısadır ismember(...,'rows')ve bir çoğaltmayı engeller. Diziler yerine hücrelere geçerek Luis Mendo sayesinde başka bir bayt kurtardı.

Açıklama:

MATLAB / Octave eşdeğerleri de dahil edilmiştir.

                 % 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

Giriş, bir format olmalıdır {'abc', 'acb'}.

Python 3 , 78 bayt

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

Çevrimiçi deneyin!

Bay Xcoder sayesinde -1 bayt

Pip , 11 bayt

@:_NIgFIPMa

Girdileri komut satırı argümanları olarak alır. Çevrimiçi deneyin!

açıklama

          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 bayt

Bu, şu ana kadar ne permütasyon yerleşik ne de rastgele karıştırma / sıralama kullanan tek başvuru olduğuna inanıyorum . Daha uzun olsa da, algoritmanın oldukça temiz olduğunu düşünüyorum.

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]

Çevrimiçi deneyin!

açıklama

Yaptığımız şey temelde şudur:

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

İşte çalıştığına dair bir kanıt:

Bir dize için S, front(S)bir karakter seçip Sönüne taşıyarak elde edilen dizeler kümesi olarak tanımlayın S. Örneğin, front(ABCDE)bir {ABCDE, BACDE, CABDE, DABCE, EABCD}.

Şimdi L, Lolası her anagramı içermeyen anagramların bir listesini düşünün (problemin tanımına göre). Biz bir dize var olduğunu göstermek isteyen Sde Lböyle front(S)en az bir anagram içeriyor S'değildir L.

Her dize için bu, çelişki yoluyla, varsayalım Siçinde L, her dize front(S)içinde de L. Bir dizi "ön" hamle yoluyla herhangi bir dizginin keyfi bir permütasyonunu oluşturabileceğimizi gözlemleyin. Örneğin, almak için

ABCDE -> BAEDC

Biz yapabiliriz

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

Biz her farz olan Sin L, her S'yer front(S)de olduğu L. Bu aynı zamanda her girişin S''içinde front(S')olduğu anlamına gelir L. Bu nedenle, Solduğu L, her permütasyon Siçinde de L. O zaman Ltam bir anagram seti, bir çelişki olmalı.

Biz o garantilidir beri Yani, en azından bir permütasyon olduğu değil de L, bir dize var olmalıdır Siçinde Lbazıları için S'de front(S)değil L. QED.

Kod yineler front(S)her biri için Sde Lseçer ve bir S'de olmadığı L. Yukarıdaki sonuçlara göre, en az bir tane S'hak kazanacak .

C # (Visual C # Etkileşimli Derleyici) , 116 96 bayt

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

Golf yeteneklerim, bunu ilk gönderdiğimden beri kesinlikle daha iyi oldu!

Çevrimiçi deneyin!

JavaScript (ES7), 172 bayt

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

Dizide bulunmayan dizinin ilk elemanının ilk sözlük bilgisini bulun.

Kotlin , 104 bayt

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

Beautified

{
    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çek

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 bayt

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

Çevrimiçi deneyin!

Scala, 50 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

İlk girişten gelen harfleri tekrar tekrar örnekleyin (birbirlerinin anagramı olması gerektiği gibi) ve bu örneklerden biri orijinal listede olmadığında durun.

Kabuğu , 6 bayt

←-⁰P←⁰

Çevrimiçi deneyin!

PHP , 70 bayt

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

Bir web sunucusunda çalıştırın, 0 endeksli get değerleri girin veya çevrimiçi deneyin!

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 bayt

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

belirli olmayan; komut satırı argümanlarından girdi alır

İle çalıştırın php -r <code>boşlukla follwed kelimeleri ayrılmış veya çevrimiçi denemek .

Ataşesi , 16 bayt

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

Çevrimiçi deneyin!

açıklama

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

Alternatifler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

J , 25 bayt

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

Girdi, kutulanmış dizgelerin bir listesidir - bunun böyle adil olduğunu ve dizgelerin listesini açıkça 4 8 $ 'abcde123', 'ab3e1cd2', '321edbac', 'bcda1e23' olarak açıklamaması gerektiğini hissettim.

Kodumdaki @ karışıklığı sevmiyorum, ancak bu sefer çok fazla seri hale getirilmiş fiil var.

Nasıl çalışır:

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

Çevrimiçi deneyin!

05AB1E , 5 bayt

нœIмà

Çevrimiçi deneyin!

açıklama

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

Neredeyse @ThePirateBay'ın bulduğu cevabın aynısı.

JavaScript, 87 bayt

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

Çevrimiçi deneyin!

Bu cevap Imme'nin cevabına dayanmaktadır (yoğun olarak değiştirilmiş olmasına rağmen) . Bir yorumda önerdi bunun farklı bir cevap olması gerektiğini .

Eski yaklaşımla ilgili sorun şu ki; sort tamamen uygulamaya bağlı olmasıdır. Standart, sıralama işlevini çağırmanın sırasını garanti etmez, bu nedenle teorik olarak birinci veya ikinci test durumu için hiçbir zaman bitmeyebilir.

Bu yaklaşım birkaç byte daha uzundur, ancak Math.randomasla geri dönmese bile sınırlı sürede biteceğini garanti eder .5.

CJam , 11 bayt

q~_0=m!\m0=

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Girişin ilk dizesini, girişin bir öğesi olmayana kadar rasgele karıştırır.

Açıklama:

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