একটি আনগ্রামে আউটপুট! না নট দ্যাট ওয়ান!

28

একে অপরের অ্যানগ্রগ্রামগুলি স্বতন্ত্র স্ট্রিংয়ের একটি তালিকা দেওয়া হয়েছে, তালিকার প্রতিটি শব্দের চেয়ে পৃথক words শব্দের একটি অ্যানগ্রাম আউটপুট।

স্ট্রিংগুলি বর্ণমালিক হবে এবং এখানে একটি বৈধ অ্যানগ্রগ্রাম হওয়ার নিশ্চয়তা রয়েছে।

প্রোগ্রাম বা ফাংশনটি করতে পারে, তবে অ-প্রতিরোধমূলক হতে হবে না, যার অর্থ একই ইনপুট দেওয়া হয়েছে, কোডের একাধিক চলমান বিভিন্ন আউটপুট দিতে পারে, যতক্ষণ সম্ভব প্রতিটি আউটপুট বৈধ থাকে one

পরীক্ষার মামলা

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

এটি অনলাইন চেষ্টা করুন!

— মিঃ এক্সকোডার
সূত্র
4
তবে itertoolsএর উত্তর কি কখনও?
— মাইল্ডলি মিল্কিওয়েস্ট
@ মিস্টাফিগগিনস মনোনীত
— মিঃ এক্সকোডার
@ মিঃ এক্সকোডার 22 জুলাই 2015 এর আগে
— স্টান স্ট্রাম
@ স্ট্যানস্ট্রাম আমি কেবল এটি উল্লেখ করেছি, আমি এই সীমাবদ্ধতা সম্পর্কে সচেতন। স্টিভি যেমন বলেছিল ...
— মিঃ এক্সকোডার
1
@ jpmc26 হ্যাঁ, আপনি f=\চেষ্টা করুন এটি অনলাইন শিরোনামে রেখে ফাংশনটি বেনামে রেখে দিতে পারেন, স্বয়ংক্রিয়
— টিও
9

05 এ বি 1 ই , 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Œ!ḟµḢ

এটি অনলাইন চেষ্টা করুন!

05AB1E এবং পাইথ উত্তরের চেয়ে 1 বাইট বেশি।

ব্যাখ্যা:

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
সূত্র
এফওয়াইআই তীর ফাংশন অনুমোদিত (উদাহরণস্বরূপ a=>bপরিবর্তে function(a){return b})। এটি অনেকগুলি বাইট সংরক্ষণ করে।
বাহ ... যা বেশ কয়েকটা বাইট সাশ্রয় করবে।
— ইমমে
s.split("")হতে পারে [...s]। এছাড়াও join("")`হতে পারে join```
— রিক হিচককের
@ পাইরেটবে আমি ভয় পেয়েছিলাম যে ঘটনাটি ঘটবে, তবে তা কেন? (আমি সচেতন যে বাছাই পুরোপুরি এলোমেলো নয়, তবে সমস্ত ক্রমগুলি অবশ্যই সম্ভব হবে)
— ইম্ম
@Imme। এখানে 87 বাইট ওয়ার্কিং সংস্করণ। লক্ষ্য করুন যে আপনার sortফাংশনটি কখনই ফিরে আসে না 0(বা কমপক্ষে অত্যন্ত বিরল), তাই এটি কার্যকর হয়নি didn't
4

হাস্কেল , 58 বাইট

-1 বাইট এবং একটি স্থির ধন্যবাদ লাইকোনিকে।

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

এটি অনলাইন চেষ্টা করুন!

Data.Listএগুলি সম্ভবত অনুমোদনের জন্য আমদানি করার মতো নয় তবে এএইচ।

— totallyhuman
সূত্র
1
আপনি এটি দিয়ে একটি বাইট সংরক্ষণ করতে পারেন notElem। আমি যদি অবাক হয়ে থাকি যে কেউ যদি আমদানিকে মারধর করে এমন কোনও ক্রোমিটেশন ক্রিয়াকলাপ খুঁজে পান, তবে আমার সংক্ষিপ্ততম পদ্ধতিটি 60 বাইট বনাম বনাম 29 বাইট is
— লাইকনি
1
এখানে একটি 43 বাইটের অনুক্রমের ক্রিয়াকলাপ রয়েছে তবে কেবল নকল ফ্রি তালিকার জন্য।
— লাইকনি
1
এছাড়াও আপনার সমাধান বর্তমানে কাজ করছে না কারণ $আগে অনুপস্থিত l!!0।
— লাইকনি
3

জাপট , 7 6 বাইট

-১ বাইট @ শ্যাগিকে ধন্যবাদ

á 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

এমএটিএল , 15 , 13 , 12 বাইট

1X)Y@Z{GX-1)

এটি অনলাইন চেষ্টা করুন!

সানচাইসিসকে 2 বাইট সংরক্ষণ করা হয়েছে। setdiff(...,'rows')অবহেলা করার চেয়ে ছোট ismember(...,'rows')এবং এটি একটি সদৃশ এড়িয়ে চলে। অ্যারেগুলির পরিবর্তে কোষগুলিতে স্যুইচ করে লুইস মেন্ডোকে আরও একটি বাইট ধন্যবাদ সংরক্ষণ করা হয়েছে।

ব্যাখ্যা:

ম্যাটল্যাব / অক্টাভ সমতুল্যও অন্তর্ভুক্ত রয়েছে।

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

এটি অনলাইন চেষ্টা করুন!

-১ বাইট মিঃ এক্সকোডারকে ধন্যবাদ

— HyperNeutrino
সূত্র
if x not in aহয় if~-(x in a)জন্য 178
— জনাব Xcoder
@ Mr.Xcoder। মানে 78, তাই না?
@ দস্যুরাটি বে হ্যাঁ, আমি ... ওফ!
— মিঃ এক্সকডার
1
কিভাবে প্রায় 66 বাইট ?
— NieDzejkob
1
পছন্দ করুন আপনি চাইলে আপনার নিজের পোস্ট করা উচিত
— 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।

কোড উপর iterates 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

জাভাস্ক্রিপ্ট (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

অ্যারেতে অন্তর্ভুক্ত নেই এমন অ্যারের প্রথম উপাদানটির প্রথম লিক্সিকোগ্রাফিক ক্রমায়নটি সন্ধান করুন।

— নিল
সূত্র
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

প্রথম প্রবেশের চিঠিগুলি বারবার নমুনা করুন (সেগুলি একে অপরের অ্যানগ্রগ্রাম হওয়া উচিত) এবং যখন সেই নমুনাগুলির মধ্যে একটি মূল তালিকাতে না থাকে তখন থামুন।

— অ্যান্ড্রু হেইনেস
সূত্র
— : Giuseppe
1

কাস্তে , 6 বাইট

←-⁰P←⁰

এটি অনলাইন চেষ্টা করুন!

— মিঃ এক্সকোডার
সূত্র
এটি দৈর্ঘ্যের 2 এর চেয়ে বেশি ইনপুটগুলির জন্য কাজ করে বলে মনে হচ্ছে না ?
— মাইল্ডলি মিল্কিওয়েস্ট
@ মিস্টাফিগিনস আপনার অ্যারে আক্ষরিক শূন্যস্থান রাখতে পারবেন না: tio.run/##yygtzv7//1HbBN1HjRsCgDSQ@v//…
— মার্টিন এন্ডার
1

পিএইচপি , 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

পিএইচপি, 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 $ '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

এটি অনলাইন চেষ্টা করুন!

— গ্যালেন ইভানভ
সূত্র
1
একটি টেবিল হিসাবে ইনপুট গ্রহণ, 21 বাইট জন্য: {.@(-.~i.@!@#@{.A.{.)। এটি অনলাইন চেষ্টা করুন!
— জোনা
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"
— Esolanging ফল
সূত্র
আমি মনে করি আপনার ব্যাখ্যায় একটি টাইপও থাকতে পারে - আপনার কোড যা উত্তর দেয় তা আপনার ব্যাখ্যা
— বলার
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
— জো কিং
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.