26

ইনপুট:

একটি বিন্যাস তিন পূর্ণসংখ্যার ধারণকারী: 0, 1এবং 2কোনো অনুক্রমে (যেমন [2, 0, 1])
এবং দৈর্ঘ্যের একটি স্ট্রিং> = 2 কেবল বর্ণানুক্রমিক অক্ষর (উভয় নিম্ন- এবং বড় হাতের) এবং অঙ্কগুলি (যেমন a1B2c3) থাকে

আউটপুট:

অ্যারের উপর ভিত্তি করে আমরা স্ট্রিংটিকে বাছাই করে আউটপুট করি।
কিভাবে কাজ করে?

অ্যারের অর্ডার প্রাধান্য ইঙ্গিত a-z, A-Zএবং 0-9প্রথম হচ্ছে, 0; দ্বিতীয় সত্তা 1; এবং তৃতীয় সত্তা 2।
তারপরে স্ট্রিংয়ের স্বতন্ত্র অক্ষরগুলি তারপরে অর্ডার করা যেতে পারে।

উদাহরণ:

এরে: [2, 0, 1]
স্ট্রিং: a1B2c3

অ্যারের উপর ভিত্তি করে, আমরা জানি আমাদের অর্ডার অগ্রাধিকার 0-9a-zA-Z।
যে উপর ভিত্তি করে আমরা এবং আউটপুট রূপান্তর করতে পারেন: STRING 123acB।

চ্যালেঞ্জ বিধি:

অ্যারের জন্য আপনি 0-ইনডেক্সড বা 1-ইনডেক্সড ইনপুট ব্যবহার করতে বেছে নিতে পারেন, [3, 1, 2]আপনি যদি 1-ইনডেক্সেড অ্যারে ব্যবহার করতে পছন্দ করেন তবে এটি একটি বৈধ ইনপুটও।
স্ট্রিং (উভয় ইনপুট এবং আউটপুট) শুধুমাত্র বৈধ অক্ষর রয়েছে: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789।
আপনার ভাষা অ্যারে সমর্থন করে না থাকেন (অথবা যদি আপনি করতে পছন্দ করে নিন), আপনি প্রথম প্যারামিটার (অর্থাত জন্য অ্যারে পরিবর্তে স্ট্রিং ব্যবহার করতে পারবেন সেগুলি 012, [0,1,2], ইত্যাদি)।

সাধারাইওন রুল:

এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর।
কোড-গল্ফ ভাষাগুলি আপনাকে নন-কোডগলফিং ভাষার সাথে উত্তর পোস্ট করতে নিরুৎসাহিত করবেন না। 'যে কোনও' প্রোগ্রামিং ভাষার পক্ষে যতটা সম্ভব সংক্ষিপ্ত উত্তর নিয়ে আসার চেষ্টা করুন।
স্ট্যান্ডার্ড নিয়মগুলি আপনার উত্তরের জন্য প্রযোজ্য , সুতরাং আপনাকে সঠিক পরামিতিগুলি, সম্পূর্ণ প্রোগ্রামগুলির সাথে STDIN / STDOUT, ফাংশন / পদ্ধতি ব্যবহারের অনুমতি দেওয়া হবে। আপনার কল
ডিফল্ট লুফোলগুলি নিষিদ্ধ।
যদি সম্ভব হয় তবে আপনার কোডের জন্য একটি পরীক্ষার সাথে একটি লিঙ্ক যুক্ত করুন।
এছাড়াও, প্রয়োজন হলে একটি ব্যাখ্যা যোগ করুন।

পরীক্ষার কেস:

[2, 0, 1]  &  a1B2c3             ->   123acB
[2, 1, 0]  &  aAaA909UuHWw9gh2   ->   02999AAHUWaaghuw
[2, 1, 0]  &  6Bx43              ->   346Bx
[1, 0, 2]  &  jfjf33g            ->   ffgjj33
[0, 2, 1]  &  AbC13              ->   b13AC
[1, 2, 0]  &  Qfl0l              ->   Q0fll
[0, 1, 2]  &  9870abcABC         ->   abcABC0789
[0, 2, 1]  &  test123            ->   estt123
[2, 0, 1]  &  WHAT               ->   AHTW
[2, 0, 1]  &  WhAt               ->   htAW
[1, 0, 2]  &  102BACbac          ->   ABCabc012

— কেভিন ক্রুইজসেন
সূত্র

চান "123"প্রথম প্যারামিটার জন্য একটি বৈধ বিন্যাস হবে?

— মেগো

সম্পর্কিত: একটি আদেশ অনুকরণ করুন

— xnor

@ মেগো হ্যাঁ না কেন। এটি চ্যালেঞ্জের মূল অংশটিকে প্রভাবিত করছে না। পরিবর্তনটি প্রতিবিম্বিত করতে আমি আমার প্রশ্ন সম্পাদনা করেছি। বিনা দ্বিধায় ব্যবহার করুন 123, 012, [0,1,2], [0, 1, 2], 0;1;2বা যেটা আপনি পছন্দ করেন।

— কেভিন ক্রুইজসেন

5

05 এ বি 1 ই , 15 14 12 বাইট

কোড:

v²žK26ôyèÃ{?

ব্যাখ্যা:

v             # For each in the input array.
  žK          #   Push a-zA-Z0-9.
    26ô       #   Split into pieces of 26.
       yè     #   Get the element-th element of the array.
 ²       Ã    #   Keep the characters of that element from the second input.
          {?  #   Sort pop and print without a newline.

সিপি -1222 এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন! ।

— আদনান
সূত্র

এর পরিবর্তে ²এবং ব্যবহার করে এটি এখন 10 বাইট হতে পারে । ₂26

— কেভিন ক্রুইজসেন

8

পাইথন 2, 67 66 বাইট

lambda s,k:`sorted(s,key=lambda c:`k.index(3-ord(c)/32)`+c)`[2::5]

আইডিয়নে এটি পরীক্ষা করুন ।

— ডেনিস
সূত্র

7

জাভাস্ক্রিপ্ট (ES6), 87 বাইট

(a,s)=>a.map(n=>[...s].sort().join``.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

যদি ইনপুট অ্যারেটি তিনটি ব্যাপ্তির পূর্বের চেয়ে অর্ডার দেয় (এটি কেবল তার জন্য একটি পার্থক্য করে [1, 2, 0]এবং [2, 1, 0]যার প্রভাবগুলি অদলবদল হয়) তবে এটি ৮০ বাইটের জন্য কাজ করতে পারত:

(a,s,o=c=>a[(c<'a')+(c<'A')])=>[...s].sort((a,b)=>o(a)-o(b)||(a>b)-(a<b)).join``

আমি প্রশ্নটি ভুলভাবে পড়েছি এবং এখনও এটির সাথে 7 টি আপগেট পেয়েছি। আপনার আপবোটগুলি সরিয়ে ফেলার জন্য নির্দ্বিধায় এবং তাদের পরিবর্তে @ চার্লিউইনকে দিন, যিনি আমার পদ্ধতির সেরা সংশোধন নিয়ে এসেছেন।

(a,s)=>a.map(n=>s.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

— নিল
সূত্র

3

ওহ, খুব আকর্ষণীয় সমাধান! Optionচ্ছিক Array.sortফাংশন প্যারামিটারটি ব্যবহার করার জন্য আমি একটি ভিন্ন ES6 উত্তরের কথা ভাবছিলাম তবে এটি আরও খারাপ।

— charredgrass

1

আমি এই সমাধানটি সত্যিই পছন্দ করি তবে আমার মনে হয় এটি 2, 3 এবং সম্ভবত অন্যদের পরীক্ষায় ব্যর্থ। আমার ধারণা আপনি তিনটি বিভাগের প্রতিটি সাজানোর কথা?

— চার্লি ওয়েন

@ চর্লিউইন দুঃখিত, আমার অবশ্যই প্রশ্নটি ভুল পড়ে থাকতে হবে। (এটি আমার একটি সাধারণ দোষ))

— নীল

@ নীল, আমি মনে করি না যে প্রশ্নটি অ্যারে বাছাই করা খুব পরিষ্কার করে দিয়েছে, কেবল পরীক্ষার কেসগুলিতে এই বৈশিষ্ট্যটি রয়েছে বলে মনে হয়েছে।

— চার্লি ওয়েন

@ চর্লিউইন বেশিরভাগ পরীক্ষার কেস ইতিমধ্যে কমপক্ষে / উচ্চ / সংখ্যাযুক্ত অংশগুলিকে সাজানো দেখা গেছে ...

— নীল

5

জেলি , 13 বাইট

2_ịØWs26¤Ff@€

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

2_ịØWs26¤Ff@€  Main link. Arguments: k (permutation of [0, 1, 2]), s (string)

2_             Subtract the integers in k from 2, mapping [0, 1, 2] -> [2, 1, 0].
        ¤      Combine the three links to the left into a niladic chain.
   ØW          Yield the string following string.
               'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_'
     s26       Split it into chunks of 26 chars, i.e., ['A...Z', 'a...z', '0...9'].
  ị            Retrieve the chunks from the right result at the indices of the
               left result. The indices of the chunks are modular and 1-based;
               1 retrieves 'A...Z', 2 retrieves 'a...z', and 3 retrieves '0...9'.
         F     Flatten the resulting array of strings.
          f@€  Filter (swapped, each); for each character in the constructed
               string, select all occurrences of that character from s.

— ডেনিস
সূত্র

5

পাইথ, 17 16 15 বাইট

s@RSz@L[GrG1`UT

পরীক্ষা স্যুট.

       [          array literal containing...
        G           the alphabet (lowercase)
         rG1        the alphabet, converted to uppercase
            `UT     inspect-range-10, generating the range [0,10) and
                      stringifying it, resulting in a string that contains no
                      letters and all numbers (so equivalent to '0123456789' for
                      filtering)
                    this creates ['ab...z', 'AB...Z', '01...9']

     @L           map over first (implicit) input (the ordering array) and take
                   the nth element in this array for each item
                   this gives us ['01...9', 'ab...z', 'AB...Z']

   Sz             take another line of input as a string and sort it, and then...
 @R               map over intersection: filter the line of input over presence
                    in each element in the new array
                    this results in ['123', 'ac', 'B']

s                 concatenate all and implicitly output

ধন্যবাদ @FryAmTheEggman একটি বাইট এবং জন্য @Jakube অন্যের জন্য!

— ডোরকনব
সূত্র

আপনি 'UTপরিবর্তে ব্যবহার করতে পারেন s'MT।

— জাকুব

@ জাকুব আমি একটি উদ্ধৃতি নয়, একটি ব্যাকটিক ব্যবহার করছি। তবে 'UTএটি একটি ত্রুটি, এবং `UTএকই স্ট্রিংয়ের ফল হয় না।

— ডুরকনবব

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

— জাকুব

@ জাকুব ওহ, আমি দেখছি এটাই চালাক; ধন্যবাদ!

— ডুরকনব

5

জাভাস্ক্রিপ্ট এস6 77 বাইট

(a,s)=>a.map(o=>s.match([/[a-z]?/g,/[A-Z]?/g,/\d?/g][o]).sort().join``).join``

//test
f=(a,s)=>a.map(o=>(s.match([/[a-z]/g,/[A-Z]/g,/\d/g][o])||[]).sort().join``).join``


f([2, 0, 1], "a1B2c3")             == "123acB" &&
f([2, 1, 0], "aAaA909UuHWw9gh2")   == "02999AAHUWaaghuw" &&
f([2, 1, 0], "6Bx43")              == "346Bx" &&
f([1, 0, 2], "jfjf33g")            == "ffgjj33" &&
f([0, 2, 1], "AbC13")              == "b13AC" &&
f([1, 2, 0], "Qfl0l")              == "Q0fll" &&
f([0, 1, 2], "9870abcABC")         == "abcABC0789" &&
f([0, 2, 1], "test123")            == "estt123" &&
f([2, 0, 1], "WHAT")               == "AHTW" &&
f([2, 0, 1], "WhAt")               == "htAW" &&
f([1, 0, 2], "102BACbac")          == "ABCabc012"

— চার্লি উইন
সূত্র

@ নিলের খুব ঝরঝরে রেগেক্স অ্যারে ধারণাটি চুরি করেছে

— চার্লি ওয়েন

?প্রতিটি রেজেক্সে এস যুক্ত করে, এটি নিশ্চিত করে যে ম্যাচ ফলাফল দেয় (বেশিরভাগ ফাঁকা স্ট্রিং, তবে তারা যেভাবে যাইহোক অদৃশ্য হয়ে যায়) (||[]), যাতে আপনাকে সামগ্রিকভাবে 3 বাইট সাশ্রয় করে।

— নিল

@ নিল বিস্ময়কর, ধন্যবাদ .. আপনি নিশ্চিত ছিলেন না যে আপনি কেন তাদের মধ্যে ছিলেন: পি

— চার্লি উইন

4

TSQL, 199 191 বাইট

Golfed:

DECLARE @i varchar(99)='abA7B34',@s char(3)='213'

,@ varchar(99)=''SELECT @+=n FROM(SELECT top 99n FROM(SELECT top 99substring(@i,row_number()over(order by 1/0),1)n FROM sys.messages)c ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n)d SELECT @

Ungolfed:

DECLARE @i varchar(99)='abA7B34'
-- 1 numbers, 2 upper case, 3 lower case
DECLARE @s char(3)='213'


,@ varchar(99)=''
SELECT @+=n
FROM
  (
    SELECT top 99 n 
    FROM
      (
         SELECT top 99substring(@i, row_number()over(order by 1/0), 1)n
         FROM sys.messages
      )c
    ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n
  )d

SELECT @

বেহালা

— t-clausen.dk
সূত্র

3

এপিএলএক্স , 19 বাইট

s[(∊(⎕a⎕A⎕D)[a])⍋s]

⎕a⎕A⎕D উচ্চতর সংখ্যা

(… )[a]অ্যারে অনুসারে পুনঃক্রম করুন a

∊ চেপটান

(... )⍋sযে "বর্ণমালা" অনুযায়ী, সূচকের যে সাজানোর হবে স্ট্রিং দিতে গুলি

s[… এর] পুনঃক্রম করতে এটি ব্যবহার করুন

— আদম
সূত্র

খুব খারাপ ডায়ালগ এপিএল-তে নেই এবং ছোট হাতের অনুবাদে বড় হাতের সমাধানে অনেকগুলি বাইটস লাগে :-) নয় যে আমি ডায়ালগ এপিএলকে অন্তর্ভুক্ত করার পরামর্শ দিচ্ছি না - এটি প্রদত্ত যে এর কার্যকারিতা বেশ কমে যাবে কোড-গল্ফিং চ্যালেঞ্জগুলি, যতদূর আমি বলতে পারি

— lstefano

@lstefano আমি পছন্দ করি না ⎕a, কারণ এটি কেস-সংবেদনশীল কোয়াড নাম। অনেক ভাল (গল্ফিং এবং সাধারণভাবে) আমি যার জন্য তদবির করছি; পেতে ⌈এবং ⌊চরিত্র ডেটার উপর কেস ভাঁজ, ঠিক কে মধ্যে তারপর আমরা আছে ⌊⎕Aপরিবর্তে ⎕a।

— অ্যাডম

2

পাইথন 2, 121 বাইট

lambda a,s:"".join(sum([[sorted(filter(eval(u),s))for u in["str.islower","str.isupper","str.isdigit"]][i]for i in a],[]))

— জেরেমি
সূত্র

2

Clojure, 74 বাইট

#(apply str(mapcat sort(for[i %](re-seq([#"[a-z]"#"[A-Z]"#"[0-9]"]i)%2))))

প্রথম তালিকার প্রতিটি মানের জন্য, উপযুক্ত রেজেেক্স পান এবং এটি ইনপুট স্ট্রিংয়ে প্রয়োগ করুন। ফলাফলটি হ'ল প্রতীকগুলির তালিকার একটি তালিকা যা রেজেসের সাথে মেলে। তারপরে প্রত্যেককে বাছাই করুন এবং ফলাফলটিকে একটি তালিকার সাথে সংযুক্ত করে স্ট্রিংয়ে রূপান্তর করুন।

আপনি এটি অনলাইনে এখানে দেখতে পাবেন: https://ideone.com/dqAkxg

— cliffroot
সূত্র

2

রেটিনা , 43 39 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে। পেছনের লাইনফিডটি তাৎপর্যপূর্ণ।

2=`.
!$&"
T04`¶d`#^@%
O`\W?.
O`.\w+
\W

ইনপুটটি প্রথম লাইনে ডিলিমিটার ছাড়াই শূন্য-ভিত্তিক তালিকা হিসাবে সাজানো ক্রম এবং দ্বিতীয় লাইনে স্ট্রিংটি সাজানোর জন্য প্রত্যাশিত

120
fOo42BaR

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

ব্যাখ্যা

কোডের মাধ্যমে আপনাকে চলতে আমি উপরের ইনপুট উদাহরণটি ব্যবহার করব:

120
fOo42BaR

মঞ্চ 1: প্রতিস্থাপন

2=`.
!$&"

রেজেক্স নিজেই ঠিক .(যে কোনও নন-লাইনফিডের অক্ষরের সাথে মেলে), যা ঘিরে রয়েছে !..."। তবে রেটিনাকে কেবলমাত্র রেগেক্সের দ্বিতীয় ম্যাচে প্রতিস্থাপন প্রয়োগ করতে বলার 2=এটি সীমাবদ্ধতা । সুতরাং আমরা এটি পেতে:

1!2"0
fOo42BaR

দ্বিতীয় পর্যায়: লিপি:

T04`¶d`#^@%

প্রতিবর্ণীকরণের পর্যায়ে কেবল অক্ষর দ্বারা অক্ষর প্রতিস্থাপন করা হয়। ¶একটি লাইনফীড এবং প্রতিনিধিত্ব করে dবিস্তৃতি 0123456789(যদিও আমরা পরে ভাবে সংখ্যা বসিয়ে উপেক্ষা করতে পারেন 2)। তার অর্থ, এই লিখিত লিখনটি নিম্নলিখিত ম্যাপিংয়ের সাথে মিলে যায়:

¶012
#^@%

04সামনের দুটি সীমা, যা একসঙ্গে নির্দেশ করে যে শুধুমাত্র প্রথম চার এই সেট থেকে অক্ষর বর্ণান্তরিত করা উচিত। এটি প্রথম লাইনে অঙ্কগুলি হ'ল পাশাপাশি লাইনফিডটি দুটি লাইনকে পৃথক করে, সুতরাং আমরা এটি পাই:

@!%"^#fOo42BaR

স্ট্রিংয়ের সামনের দিকে আমরা এখন এই অক্ষরটির তিন জোড়া পেয়েছি:

@!
%"
^#

নোট করুন যে জোড়ার দ্বিতীয় অক্ষরগুলি কেবল তাদের সাধারণ ASCII ক্রমে থাকে (এবং সর্বদা একই থাকে)। মূল ইনপুটে অক্ষরের গোষ্ঠীগুলিকে প্রয়োজনীয় ক্রমে সাজানোর জন্য আমরা এগুলি পরে ব্যবহার করব।

প্রথম অক্ষরগুলি আরও আকর্ষণীয়: তাদের তাত্পর্যটি হ'ল %ASCII সারণীতে অঙ্কগুলির আগে আসে, @বড় হাতের অক্ষরের আগে আসে (তবে অঙ্কগুলির পরে), এবং ^ছোট ছোট অক্ষরের (তবে বড় হাতের অক্ষরের পরে) আসে। এটি আমাদের সঠিক অবস্থানের অক্ষরের সাথে অবস্থান চিহ্নিতকারীদের গ্রুপ করতে সহায়তা করবে (অর্থাত্ প্রতিটি জোড়ের দ্বিতীয় অক্ষর)।

পর্যায় 3: বাছাই করুন

O`\W?.

এটি একটি সাধারণ সাজানোর মঞ্চ। এটি দুটি অক্ষরের সাথে মিলে যায় যদি প্রথমটির একটি শব্দ অক্ষর না হয় (এর মাধ্যমে আমি কেবল তিনটি জুটির সাথেই কথা বলি) বা একটি একক অক্ষর (অন্যথায় মূল ইনপুটটির প্রতিটি চরিত্রের সাথে স্বতন্ত্রভাবে মিলে যায়), এবং সেগুলিগুলি বাছাই করে। এই দুটি উদ্দেশ্য আছে: এটা অক্ষর এনেছে মধ্যে সঠিক অনুক্রমে প্রতিটি দলের (এবং যেহেতু বাছাই সুস্থিত হয়, এই আদেশ পরবর্তী পর্যায়ে বিশৃঙ্খলার সৃষ্টি হবে না), এবং কারণে এটা %@^মার্কার, তাতে জোড়া সন্নিবেশ সঠিক অবস্থান:

%"24@!BOR^#afo

পর্যায় 4: বাছাই করুন

O`.\w+

এই পর্যায়টি রেজেক্সের সমস্ত মিলগুলি .\w+সাজায় যা লোভের কারণে, !"#এরপরে সমস্ত শব্দের অক্ষরের সাথে এক অবস্থানের মার্কার (অর্থাত্ একটি ) এর সাথে মেলে । এটি হ'ল এটি এই তিনটি স্ট্রিং সাজায়, যার ক্রমটি কেবল চিহ্নিতকারী চরিত্র দ্বারা নির্ধারিত হয়:

"24! বিওআর # এফও

এই চিহ্নিতকারীগুলির চারপাশে এই পরিবর্তনগুলি ঘটে (অন্য তিনটি চিহ্নিতকারীকে জায়গায় রেখে দেওয়ার পরে), সর্বাধিক গুরুত্বপূর্ণভাবে এটি অঙ্ক এবং অক্ষরগুলি সঠিক ক্রমে নিয়ে আসে:

%!BOR@"24^#afo

মঞ্চ 5: প্রতিস্থাপন

\W

যা কিছু অবশিষ্ট রয়েছে তা হ'ল কিছুটা পরিষ্কার-পরিচ্ছন্নতা, যেখানে আমরা সমস্ত চিহ্নিতকারীকে তাদের সাথে মেলে এবং কিছু না করে প্রতিস্থাপন করে সরিয়ে ফেলি।

— মার্টিন ইন্ডার
সূত্র

2

জাভাস্ক্রিপ্ট (ES6), 65

দ্রষ্টব্য: 'প্রাকৃতিক' এএসসিআইআই অর্ডার 0-9, এজেড, এজেড, এটি ওপি 0,1,2 এর ঠিক বিপরীত। সুতরাং

স্ট্রিংকে আলাদা রান করতে অবৈধ অক্ষর যুক্ত করুন
এটি 3 টি সেগমেন্টে বিভক্ত করুন - প্রতিটি অবৈধ অক্ষর চিহ্নিত করুন
অনুরোধ অনুসারে একের পর এক বিভাগগুলি পান
পুনরায় একত্রে

s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

F=s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

;[['201','a1B2c3','123acB']
,['210','aAaA909UuHWw9gh2','02999AAHUWaaghuw']
,['210','6Bx43','346Bx']
,['102','jfjf33g','ffgjj33']
,['021','AbC13','b13AC']
,['120','Qfl0l','Q0fll']
,['012','9870abcABC','abcABC0789']
,['021','test123','estt123']
,['201','WHAT','AHTW']
,['201','WhAt','htAW']
,['102','102BACbac','ABCabc012']]
.forEach(t=>{
  var w=t[0],s=t[1],k=t[2], r=F(s)([...w])
  console.log(w,s,r,(r==k?'OK':'KO (expected '+k+')'))
})

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

2

হাস্কেল, 62 63 বাইট

a#b=[c|i<-b,c<-[' '..],d<-a,d==c,div(fromEnum c)16==[6,4,3]!!i]

ব্যবহারের উদাহরণ: "cD12ab" # [2,0,1]-> "12abcD"।

কিভাবে এটা কাজ করে:

i<-b                                  -- loop i through the input array
   [c|   c<-[' '..]]                  -- loop through all chars c
       d<-a                           -- loop through all chars d in the input string
       d==c                           -- and keep those that are in the input string
       div(fromEnum c)16==[6,4,3]!!i  -- and where the the ascii value divided by
                                      -- 16 equals the number from [6,4,3] indexed
                                      -- by the current i

সম্পাদনা করুন: @ খ্রিস্টিয়ান সিভার্স একটি বাগ খুঁজে পেয়েছে। ধন্যবাদ! 1 টি অতিরিক্ত বাইটের জন্য স্থির।

— nimi
সূত্র

চরগুলি একাধিকবার ঘটবে কি?

— খ্রিস্টান সিভারস

@ খ্রিস্টিয়ানসিভারস: আপনি ঠিক বলেছেন, এটি একটি বাগ। সংশোধন করা হয়েছে। তোমাকে ধন্যবাদ!

— নিমি

2

স্ট্যাক্স , 15 বাইট

┐°!'àÉgYg8∟╗`╖ë

এটি চালান এবং অনলাইনে ডিবাগ করুন

এই 15 বাইট জমাটি সিপি 437 অক্ষর সেটটির একটি বৈকল্পিকের মধ্যে প্যাক করা হয়েছে। সংশ্লিষ্ট আসকি প্রতিনিধিত্ব 18 বাইট লাগে:

EVlVd+26/s@:fs{[Io

খুব নিশ্চিত যে এটি আরও ছাঁটাই করা যেতে পারে যদিও।

E                   Put the two inputs on main stack
 Vl                 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   Vd               "0123456789"
     +              Concatenate
      26/           Partition to blocks of size 26 (array `a`)
         s@         Index array `a` with the input index array
           :fs      Flatten to get a string `s`
              {[Io  Order the input string
                        Using the char array `s` as the key
                    Implicit output

VlVd+এছাড়াও হতে পারে VLA|(, যা 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZদশটি এলিমেট দ্বারা বাম দিকে ঘোরে । পুরো কোড এও হতে পারে VlVd+26/,e@:f,{[Io, যা ইনপুট স্ট্যাক দুইবার হবেন তাদের সব প্রধান স্ট্যাকে শুরুতে পড়ার, এবং একটি পৃথক (অধিক প্রথাগত) ইনপুট বিন্যাস ব্যবহার, যেমন দেখানো এই ।

— ওয়েইজুন ঝো
সূত্র

1

ডায়ালগ এপিএল , 22 বাইট

s[s⍋⍨∊(819⌶⎕A)⎕A⎕D[a]]

(819⌶⎕A) বড় হাতের অক্ষরে বড় হাতের ভাঁজ করুন

(... )⎕A⎕D[a]নিম্ন উপরের ডিজিট অ্যারের অনুযায়ী পুনর্বিন্যস্তভাবে একটি

∊ চেপটান

s⍋⍨স্ট্রিং এর জন্য গুলি , সূচকগুলি যে সাজানোর হবে পেতে র যে "বর্ণমালা" অনুযায়ী

s[… এর] পুনঃক্রম করতে এটি ব্যবহার করুন

— আদম
সূত্র

মিমি .... 819⌶ কেবল ডায়ালগ এপিএল এর ইউনিকোড সংস্করণে বিদ্যমান। সুতরাং আমি এটাকে লক্ষ্য করব যে বাইট গণনাটি 2 দিয়ে গুণ করা উচিত যেহেতু ইনপুটটি কার্যকরভাবে ইউনিকোড এন্ট্রি পয়েন্টগুলির সমন্বয়ে গঠিত O বা এপিএল জমা দেওয়ার জন্য বাইট গণনা সম্পর্কে আমার বোঝা ভুল?

— lstefano

@ এলস্টেফানো ইউনিকোড সংস্করণটি ক্লাসিক ওয়ার্কস্পেসগুলি লোড করতে সক্ষম হয়েছে, তাই না?

— অ্যাডম

এটি

— লুক্কায়িত

1

পাওয়ারশেল ভি 2 +, 107 বাইট

param($n,[char[]]$s)-join(-join(($s=$s|sort)|?{$_-ge97}),-join($s|?{$_-in65..96}),-join($s|?{$_-lt58}))[$n]

আমি রেজেক্স ব্যবহার করে অ্যালগরিদমগুলি অন্বেষণ করছি, তবে এ পর্যন্ত এগুলি সমস্ত দীর্ঘতর বলে মনে হচ্ছে।

সুস্পষ্ট অ্যারে $n(নীচের উদাহরণগুলি দেখুন) এবং স্ট্রিং হিসাবে ইনপুট নেয় $sযা অবিলম্বে একটি চর-অ্যারেতে ফেলে দেওয়া হয়। তারপরে আমরা একটি নতুন গতিশীল অ্যারের তিনটি উপাদান তৈরি করছি, তাদের প্রত্যেককে একটি দিয়ে আবদ্ধ করা হয়েছে -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

প্রথমটি আমরা $sএটির মাধ্যমে গ্রহণ করি Sort-Object। ধন্যবাদ, যেহেতু আমরা ইতিমধ্যে এটি একটি চর-অ্যারে হিসাবে ফেলেছি তাই এটি কেস-সংবেদনশীল বাছাই করা। এটি পুনরায় সেভ হয়ে যায় $sএবং তারপরে Where-Objectবৃহত্তর 97(যেমন, এএসসিআইআই ছোট ছোট a-z) এর একটি ধারা দিয়ে পাইপ করা হয় । দ্বিতীয়টি A-Zতৃতীয়টির জন্য 0-9।

সুতরাং আমাদের কাছে এখন স্ট্রিংগুলির একটি অ্যারে রয়েছে, যেখানে প্রতিটি স্ট্রিং তিনটি অক্ষরের ধরণের একটির সমন্বিত এবং সাজানো হয়। আমরা এর সাথে স্লাইস করি [$n]এবং তারপরে -joinফলাফলটি একসাথে আমাদের চূড়ান্ত আউটপুট স্ট্রিং তৈরি করি। এটি পাইপলাইনে রেখে গেছে এবং মুদ্রণ জড়িত।

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

PS C:\Tools\Scripts\golfing> $test = (@(2,0,1),'a1B2c3'), (@(2,1,0),'aAaA909UuHWw9gh2'), (@(2,1,0),'6Bx43'), (@(1,0,2),'jfjf33g'), (@(0,2,1),'AbC13'), (@(1,2,0),'Qfl0l'), (@(0,1,2),'9870abcABC'), (@(0,2,1),'test123'), (@(2,0,1),'WHAT'), (@(2,0,1),'WhAt'), (@(1,0,2),'102BACbac')

PS C:\Tools\Scripts\golfing> $test |%{"($($_[0]-join',')) & $($_[1])".PadRight(28)+" -> " + (.\post-determined-array-sorting.ps1 $_[0] $_[1])}
(2,0,1) & a1B2c3             -> 123acB
(2,1,0) & aAaA909UuHWw9gh2   -> 02999AAHUWaaghuw
(2,1,0) & 6Bx43              -> 346Bx
(1,0,2) & jfjf33g            -> ffgjj33
(0,2,1) & AbC13              -> b13AC
(1,2,0) & Qfl0l              -> Q0fll
(0,1,2) & 9870abcABC         -> abcABC0789
(0,2,1) & test123            -> estt123
(2,0,1) & WHAT               -> AHTW
(2,0,1) & WhAt               -> htAW
(1,0,2) & 102BACbac          -> ABCabc012

— AdmBorkBork
সূত্র

1

রুবি, 56 বাইট

@ ডেনিস উত্তর থেকে পোর্ট করা হয়েছে।

->a,s{s.chars.sort_by{|c|a.index(3-c.ord/32).to_s+c}*''}

@ নীল দ্বারা অনুপ্রাণিত হয়ে তাঁর উত্তর থেকে কিছুটা সংশোধন করা হয়েছে এমন একটি বিকল্প 58 বাইট সমাধান I

->a,s{a.map{|i|s.scan([/[a-z]/,/[A-Z]/,/\d/][i]).sort}*''}

অনলাইন সংস্করণ চেষ্টা করুন! (মন্তব্য-আউট সংস্করণ হ'ল বিকল্প সমাধান)

— মান কালি
সূত্র

1

32-বিট x86 মেশিন কোড, 70 বাইট

হেক্সে:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

এই পদ্ধতি আশা চরিত্র শ্রেণী বাছাই অর্ডার একটি 3-CHAR (0..2) শূন্য-সমাপ্ত মধ্যে স্ট্রিং হতে ESIএবং সাজানোর স্ট্রিং EDI। বাবল সাজানোর অত্যন্ত উপ-অনুকূল (কার্য-বিজ্ঞান) সংস্করণ ব্যবহার করে স্থানে বাছাই করা হয়।

0:  fc                  cld
1:  31 c0               xor eax, eax
3:  31 c9               xor ecx, ecx
5:  51                  push ecx        ;Allocate 4 bytes on the stack
6:  89 e3               mov ebx, esp    ;char EBX[4]
_loop0:                                 ;Parsing class order string
8:  ac                  lodsb
9:  84 c0               test al,al      ;Break on NULL
b:  74 0a               jz _break0
d:  34 cf               xor al, 0xCF    ;AL=~atoi(AL)
f:  04 04               add al, 4       ;'0'->3, '1'->2, '2'->1
11: 88 0c 03            mov [ebx+eax], cl    ;EBX[AL]=CL
14: 41                  inc ecx
15: eb f1               jmp _loop0
_break0:
17: 89 fe               mov esi,edi
19: 91                  xchg eax,ecx    ;ECX=0
_bsort:
1a: 60                  pusha
_cx2b:
1b: ac                  lodsb           ;Get the first char to compare
1c: 88 c2               mov dl,al       ;Save to DL
1e: c0 e8 05            shr al,5        ;Char class: [0-9]->1, [A-Z]->2, [a-z]->3
21: d7                  xlat            ;AL=EBX[AL] - priority for the char class 
22: 88 c6               mov dh,al       ;... goes to DH
24: 52                  push edx        ;First "comparable char" in DX goes to the stack
25: ac                  lodsb           ;Get the second char to compare
26: 88 c2               mov dl,al       ;\
28: c0 e8 05            shr al,5        ; > Same as the above
2b: d7                  xlat            ;/
2c: 88 c6               mov dh, al      ;Second "comparable char" in DX
2e: 58                  pop eax         ;The first one goes to AX
2f: 74 0e               jz _endpass     ;ZF is set by the last 'shr', and only on AL==0
31: 66 39 d0            cmp ax,dx       ;Upper halves of 32-bit regs may contain trash
34: 76 02               jbe _sorted
36: 92                  xchg eax,edx    ;Now AX<=DX
37: 41                  inc ecx         ;Swap counter
_sorted:
38: aa                  stosb           ;Store AL in-place
39: 92                  xchg eax,edx    ;AL=DL
3a: aa                  stosb           ;Store the second char
3b: 4e                  dec esi         ;Move pointers...
3c: 4f                  dec edi         ;...back one byte
3d: eb dc               jmp _cx2b       ;Repeat with the next two chars
_endpass:
3f: 85 c9               test ecx,ecx    ;Full pass completed, checking # of swaps made
41: 61                  popa            ;Restores ECX(0), ESI, EDI. Doesn't affect flags
42: 75 d6               jnz _bsort      ;If there were changes, repeat
_end:
44: 58                  pop eax         ;Deallocate EBX[]
45: c3                  ret

— meden
সূত্র

1

ইমাস লিস্প, 183 বাইট

(lambda(s p)(let(l u n)(apply'concat(mapcar(lambda(l)(sort l'<))(dolist(e(string-to-list s)(mapcar(lambda(i)(nth i(list l u n)))p))(push e(cond((< ?` e)l)((< ?@ e)u)((< ?/ e)n))))))))

জাভা থেকে সামান্য খাটো ...

— লর্ড ইউয়ুমা
সূত্র

1

ক্লোজার, 77 বাইট

#(apply str(mapcat sort(map(group-by(fn[v](condp <(int v)90 0,57 1,2))%2)%)))

re-seqভিত্তিক ব্যক্তির মতো ততটা সংক্ষিপ্ত নয় এবং আমি কীভাবে (apply str(mapcat sort(map(...))))কম জায়গায় " " প্রকাশ করতে পারি তা বুঝতে পারি না । group-byএকটি হ্যাশ-ম্যাপ তৈরি করে যা একটি ফাংশন হিসাবে ব্যবহার করা যেতে পারে, যখন 0 এবং 2 এর মধ্যে একটি ইনজিগার দিয়ে জিজ্ঞাসা করা হয় তবে এটি সংশ্লিষ্ট গ্রুপটি প্রদান করে, এটি তিনটি পৃথক শ্রেণীর অক্ষরের আদেশ দেয়।

এটি re-seqসমাধানের চেয়ে আরও কমপ্যাক্ট হতে পারে যদি হ্যান্ডেল করার জন্য আরও বেশি অক্ষর শ্রেণি থাকত কারণ এটির মত 57 1,প্রকাশের জন্য 8 এর পরিবর্তে কেবল 5 অতিরিক্ত অক্ষর / গোষ্ঠী লাগে #"[a-z]"।

— NikoNyrh
সূত্র

1

পাইথন 2, 140 117 101 100 99 বাইট

সবাই বলে, "ইওউউউ!"। কমপক্ষে এটি পঠনযোগ্য ... কাশি আসলে কাশি নয়

lambda l,s:`sorted(s,key=lambda c:[[c<'a',c<'A'or'Z'<c,c>'9'][l[i]]for i in 0,1,2]+[ord(c)])`[2::5]

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

— mbomb007
সূত্র

1

আর , 101 বাইট

function(a,s,o=unlist(list(letters,LETTERS,0:9)[a]))cat(o[sort(match(strsplit(s,'')[[1]],o))],sep='')

প্রদত্ত ক্রমে এজেড, এজেড এবং 0-9 দিয়ে একটি ভেক্টর তৈরি করে এবং এই ক্রমটি মেলানোর জন্য ইনপুট স্ট্রিংয়ের অক্ষরগুলিকে পুনর্বিন্যাস করে।

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

— রবার্ট হ্যাকেন
সূত্র

0

জে, 40 বাইট

;@:{[:(<@/:~@}./.~2-64 96 I.3&u:)'aA0'&,

— মাইল
সূত্র

0

জাভা 8, 221 212 193 156 বাইট

আমার অবশ্যই নিজের চ্যালেঞ্জের উত্তর দেওয়ার চেষ্টা করা উচিত। :) (এবং যথারীতি জাভাতে)

a->i->{for(byte c[],j=0;j<3;System.out.print(new String(c)))java.util.Arrays.sort(c=i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}

-২৮ বাইট @ ক্লিফ্রুটকে ধন্যবাদ রক্ষা করেছে ।

ব্যাখ্যা:

এখানে চেষ্টা করুন।

a->i->{          // Method with integer-array and String parameters and no return-type
  for(byte c[],  //  Temp byte-array
      j=0;j<3;   //  Loop from 0 to 3 (exclusive)
      System.out.print(new String(c)))
                 //    After every iteration: print the byte-array as String
    java.util.Arrays.sort(
                 //   Sort the byte-array
      c=         //    After we've replaced the byte-array with
        i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}
                 //    all bytes of the uppercase letters, lowercase letters, or digits,
                 //    depending on the next number in the input-array

— কেভিন ক্রুইজসেন
সূত্র

1

আপনি আপনার রেগেক্সপগুলি এর সাথে প্রতিস্থাপন [^a-z] [^A-Z] [^0-9]করতে পারেন এবং এর getBytes()পরিবর্তেtoCharArray()

— ক্লিফ্রুট

@ ক্লিফরুট ধন্যবাদ আমি রেজিজেসে খুব খারাপ, কিন্তু ব্যবহার করছিলাম না ^(বেশ) বেশ বোবা ছিল ..;)

— কেভিন ক্রুইজসেন

1

পুনরাবৃত্ত replaceAllকলগুলি সরিয়ে দেয়

String c(int[]a,String z){String r[]={"[^a-z]","[^A-Z]","[^0-9]"},o="";for(byte c[],i=0;i<3;){c=z.replaceAll(r[a[i++]],"").getBytes();java.util.Arrays.sort(c);o+=new String(c);}return o;}

— ক্লিফ্রুট

পোস্ট-নির্ধারিত অ্যারে বাছাই করা

05 এ বি 1 ই , 15 14 12 বাইট

পাইথন 2, 67 66 বাইট

জাভাস্ক্রিপ্ট (ES6), 87 বাইট

জেলি , 13 বাইট

কিভাবে এটা কাজ করে

পাইথ, 17 16 15 বাইট

জাভাস্ক্রিপ্ট এস6 77 বাইট

TSQL, 199 191 বাইট

এপিএলএক্স , 19 বাইট

পাইথন 2, 121 বাইট

Clojure, 74 বাইট

রেটিনা , 43 39 বাইট

ব্যাখ্যা

জাভাস্ক্রিপ্ট (ES6), 65

হাস্কেল, 62 63 বাইট

স্ট্যাক্স , 15 বাইট

ডায়ালগ এপিএল , 22 বাইট

পাওয়ারশেল ভি 2 +, 107 বাইট

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

রুবি, 56 বাইট

32-বিট x86 মেশিন কোড, 70 বাইট

ইমাস লিস্প, 183 বাইট

পাইথন 2, 140 117 101 100 99 বাইট

আর , 101 বাইট

জে, 40 বাইট

জাভা 8, 221 212 193 156 বাইট