आउटपुट एक विपर्यय! नो वन दैट वन!

28

अद्वितीय तार की एक सूची को देखते हुए जो एक-दूसरे के आरेख हैं, उन शब्दों के आरेख को आउटपुट करते हैं जो सूची के प्रत्येक शब्द से अलग हैं।

तार अल्फ़ान्यूमेरिक होंगे, और एक वैध विपर्यय होने की गारंटी है।

प्रोग्राम या फ़ंक्शन, लेकिन गैर-निर्धारक नहीं हो सकता है, जिसका अर्थ है कि एक ही इनपुट दिया गया है, कई कोड को चलाने से विभिन्न आउटपुट प्राप्त हो सकते हैं, जब तक कि हर संभव आउटपुट एक मान्य होता है।

परीक्षण के मामलों

[Input] -> Possible output
-----------------
[ab] -> ba
[aba, aab] -> baa
[123, 132, 231, 312, 321] -> 213
[hq999, 9h9q9, 9qh99] -> 999hq
[abcde123, ab3e1cd2, 321edbac, bcda1e23] -> ba213ecd
code-golf  string  permutations 
— MildlyMilquetoast
स्रोत

जवाबों:

20

पायथन 3 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— श्री Xcoder
स्रोत
4
लेकिन क्या itertoolsकभी इसका जवाब है?
— MildlyMilquetoast
@ मिस्ताफैगिंस नामांकित
— श्री एक्सकोडर
22 जुलाई 2015 से पहले @ मिस्टर कोडर
— स्टेन
@StanStrum मैंने अभी इसका उल्लेख किया है, मुझे उस प्रतिबंध के बारे में पता है। जैसा कि स्टीवी ने कहा ...
— श्री एक्सकोडर
1
@ jpmc26 हां, इस तरह से आप f=\इसे ऑनलाइन शीर्षक में आज़मा सकते हैं और फ़ंक्शन को अनाम छोड़ सकते हैं, जबकि स्वचालित TiO बाइट काउंटर को प्रभावित नहीं करते
— श्री Xcoder
9

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

जेली , 6 बाइट्स

XŒ!ḟµḢ

इसे ऑनलाइन आज़माएं!

1 बाइट 05AB1E से अधिक और पायथ उत्तर।

स्पष्टीकरण:

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क्योंकि यह सूची को बदलने के बिना सूची से किसी भी तत्व को लेने का सबसे छोटा तरीका है ( Ḣऔर Ṫकाम नहीं करता है, ḷ/और ṛ/लंबा है), और यह कुछ यादृच्छिकता का कारण बनता है।

µयहाँ बहुत बेमानी है, लेकिन यह बिना, Ḣके साथ रखा जाएगा ḟ, और यह है, जो क्या मैं यहाँ जरूरत नहीं है "इनपुट के सिर बाहर फिल्टर" के रूप में व्याख्या की है (मैं क्या जरूरत है इनपुट बाहर फिल्टर है ", और सिर प्राप्त करें ")।

— user202729
स्रोत
4

जावास्क्रिप्ट, 118 बाइट्स

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

प्रत्येक "यादृच्छिक" क्रमचय पर पुनरावृति करने के लिए एक खराब रैंडमाइज़र का उपयोग करता है।

शायद गलत रूप से गलत है लेकिन खराब रैंडमाइज़र को दूर करने का मतलब है कि हमें सही यादृच्छिकता नहीं मिलेगी, लेकिन फिर भी हर क्रमपरिवर्तन मिलेगा।

मेरे लिए क्रोम में सभी मामलों पर काम करने लगता है, लेकिन जाहिरा तौर पर इस तरह के दुरुपयोग में अपरिभाषित व्यवहार के कारण, यह कुछ ब्राउज़रों में काम नहीं कर सकता है।

(संभवतया बहुत ही अनगढ़ रूप से इसे अपने समाधान में सुधार करने के लिए स्वतंत्र महसूस करें)

80 बाइट्स

समुद्री डाकू की टिप्पणी के लिए धन्यवाद-बाइट्स का एक बहुत

रिक के लिए -4 बाइट्स धन्यवाद

f=a=>eval('s=[...a[0]].sort(()=>.5-Math.random()).join``;a.indexOf(s)<0?s:f(a)')
— imme
स्रोत
FYI करें तीर कार्यों अनुमति दी जाती है (उदाहरण के लिए a=>bके बजाय function(a){return b})। यह बहुत सारे बाइट्स बचाता है।
वाह ... कि काफी कुछ बाइट बचा लेंगे।
— Imme
s.split("")हो सकता है [...s]। इसके अलावा join("")`हो सकता है join```
— रिक हिचकॉक
@ ThePirateBay मुझे डर था कि मामला होगा, लेकिन ऐसा क्यों है? (im अवगत है कि सॉर्ट पूरी तरह से यादृच्छिक नहीं है, लेकिन सभी अनुक्रम संभव हो सकते हैं)
— इमाम
@Imme। यहाँ 87 बाइट्स वर्किंग वर्जन है। ध्यान दें कि आपका sortफ़ंक्शन कभी भी वापस नहीं आता 0(या कम से कम अत्यंत दुर्लभ), यही कारण है कि यह काम नहीं किया।
4

हास्केल , 58 बाइट्स

-1 बाइट और लिकोनी का धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

यह शायद Data.Listक्रमपरिवर्तन के लिए आयात करने लायक नहीं है, लेकिन एह।

— totallyhuman
स्रोत
1
आप के साथ एक बाइट बचा सकते हैं notElem। मुझे आश्चर्य होगा कि अगर किसी को एक पर्मुटेशन फ़ंक्शन मिलता है जो आयात को धड़कता है, तो मेरा सबसे छोटा दृष्टिकोण आयात के 29 बाइट्स के मुकाबले 60 बाइट्स है।
— लैकोनी
1
यहाँ एक 43 बाइट्स क्रमांकन फ़ंक्शन है, लेकिन केवल डुप्लिकेट मुक्त सूचियों के लिए।
— लकोनी
1
इसके अलावा आपका समाधान वर्तमान में काम नहीं कर रहा है क्योंकि $पहले गायब है l!!0।
— लकोनी
3

जाप , 7 6 बाइट्स

-1 बाइट @ शुगी को धन्यवाद

á 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
— जस्टिन मेरिनर
स्रोत
पागल, तुम मुझे यह करने के लिए हराया। आप व्यक्तिगत स्ट्रिंग्स के रूप में इनपुट ले सकते हैं और एक बाइट को बचा सकते हैं á kN ö।
— शैगी
@ शैगी पहला इनपुट आइटम प्राप्त करने का एक शानदार तरीका है, मुझे यह याद रखना होगा। धन्यवाद!
— जस्टिन मैरिनर
2

MATL , 15 , 13 , 12 बाइट्स

1X)Y@Z{GX-1)

इसे ऑनलाइन आज़माएं!

Sanchises के लिए धन्यवाद 2 बाइट्स सहेजे गए। setdiff(...,'rows')उपेक्षा से कम है ismember(...,'rows')और यह एक दोहराव से बचा जाता है। एरे के बजाय कोशिकाओं पर स्विच करके लुइस मेंडो के लिए एक और बाइट के लिए धन्यवाद।

स्पष्टीकरण:

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'}।

— स्टीवी ग्रिफिन
स्रोत
2

पायथन 3 , 78 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1 बाइट मिस्टर एक्सकोडर की बदौलत

— HyperNeutrino
स्रोत
if x not in aहै if~-(x in a)के लिए 178
— श्री Xcoder
@ Mr.Xcoder। तुम्हारा मतलब है 78, है ना?
@ ThePirateBay हां, मैं करता हूं ... व्हाट्स!
— श्री एक्सकोडर
1
66 बाइट्स के बारे में कैसे ?
— 12
1
@NieDzejkob यह प्रभावशाली रूप से छोटा है। यदि आप चाहते हैं तो आपको अपना पोस्ट करना चाहिए
— HyperNeutrino
2

पिप , 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
— DLosc
स्रोत
2

पायथन 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'योग्य होगा जो योग्य है।

— DLosc
स्रोत
2

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 116 96 बाइट्स

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

जब मैंने पहली बार यह पोस्ट किया था तब से मेरे गोल्फ कौशल निश्चित रूप से बेहतर हो गए हैं!

इसे ऑनलाइन आज़माएं!

— अज्ञान का अवतार
स्रोत
1

जावास्क्रिप्ट (ईएस 7), 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

सरणी के पहले तत्व का पहला लेक्सिकोग्राफ़िक क्रमांक खोजें, जो सरणी में निहित नहीं है।

— नील
स्रोत
1

कोटलिन , 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")))
}
— jrtapsell
स्रोत
1

आर, 89 बाइट्स

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

पहली प्रविष्टि से अक्षरों को बार-बार नमूना लें (जैसा कि उन्हें एक-दूसरे के आरेख होना चाहिए) और रोकें जब उन नमूनों में से एक मूल सूची में नहीं है।

— एंड्रयू हेन्स
स्रोत
— ग्यूसेप
1

भूसी , 6 बाइट्स

←-⁰P←⁰

इसे ऑनलाइन आज़माएं!

— श्री Xcoder
स्रोत
यह लंबाई 2 से अधिक इनपुट के लिए इस तरह काम नहीं करता है ?
— MildlyMilquetoast
@ मिस्टाहिफ़गिंस आपके पास सरणी शाब्दिक में रिक्त स्थान नहीं हो सकता है: tio.run/##yygtzv7//1HbBN1HjRsCgDSQ@v//…
— मार्टिन
1

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;
— SmartCoder
स्रोत
के do{...}while($j);बजाय के साथ दो बाइट्स सहेजें $j=1;while($j){...}। $gब्रेसिज़ से छुटकारा पाने के लिए और चार बाइट्स को बचाने के लिए इन-प्लेस परिभाषा का उपयोग करें ।
— टाइटस
1

PHP, 58 55 बाइट्स

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

गैर नियतात्मक; कमांड लाइन तर्कों से इनपुट लेता है

php -r <code>अंतरिक्ष से अलग शब्दों द्वारा follwed के साथ चलाएं या इसे ऑनलाइन आज़माएं ।

— टाइटस
स्रोत
1

अटैची , 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]}

— कोनोर ओ ब्रायन
स्रोत
0

जे , 25 बाइट्स

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

इनपुट बॉक्सिंग स्ट्रिंग्स की एक सूची है - मुझे लगा कि यह इस तरह से उचित था और स्ट्रिंग्स की सूचियों को स्पष्ट रूप से 4 8 $ 'एबीसीडी123', 'एब 3 ई 1 एलसीडी 2', '321 हेडबाक', 'बीसीडीए 1 ई 23' के रूप में घोषित नहीं किया गया था।

मुझे अपने कोड में @ गड़बड़ पसंद नहीं है, लेकिन इस बार बहुत सीरियस क्रियाएं हैं।

यह काम किस प्रकार करता है:

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

इसे ऑनलाइन आज़माएं!

— गैलेन इवानोव
स्रोत
1
21 बाइट्स के लिए एक तालिका के रूप में इनपुट लेना {.@(-.~i.@!@#@{.A.{.):। इसे ऑनलाइन आज़माएं!
— जोनाह
0

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 को मिला।

— Cinari
स्रोत
0

जावास्क्रिप्ट, 87 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह उत्तर इम्मे के उत्तर पर आधारित (हालाँकि भारी संशोधित) है । उन्होंने एक टिप्पणी में सुझाव दिया कि यह एक अलग उत्तर होना चाहिए।

पुराने दृष्टिकोण के साथ समस्या है क्योंकि sortपूरी तरह से कार्यान्वयन-निर्भर है। मानक सॉर्ट फ़ंक्शन को कॉल करने के आदेश की गारंटी नहीं देता है, इसलिए सैद्धांतिक रूप से यह पहले या दूसरे टेस्ट केस के लिए कभी भी समाप्त नहीं हो सकता है।

यह दृष्टिकोण कुछ बाइट्स लंबा है, लेकिन यह गारंटी देता है कि यह विवश समय में समाप्त होगा, भले ही वह Math.randomकभी वापस न आए .5।

0

सीजेएम , 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"
— फल तोड़ना
स्रोत
मुझे लगता है कि आपके स्पष्टीकरण में एक टाइपो हो सकता है - आपका उत्तर जो कोड देता है, वह आपके स्पष्टीकरण से अलग है
— MildlyMilquetoast
0

पर्ल 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
— मजाक कर रहा है
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.