ความท้าทายของคุณคือการจัดเรียงสตริง แต่แทนที่จะเรียงตามตัวอักษรปกติ (abc..xyz) คุณจะเรียงลำดับสตริงตามตัวอักษรที่ระบุ

คุณต้องเขียนโปรแกรมหรือฟังก์ชั่นที่ใช้เวลาสองอินพุต: ตัวอักษรและสตริงS ทั้งสองจะมีตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้นและทั้งสองอย่างจะมีอักขระอย่างน้อยหนึ่งตัว

คุณต้องย้ายตัวอักษรในSเพื่อให้ตัวอักษรที่ปรากฏขึ้นเป็นครั้งแรกในAปรากฏขึ้นก่อนจากนั้นตัวอักษรใดก็ตามที่ปรากฏเป็นอันดับสองในAเป็นต้นอาจมีตัวอักษรบางตัวในSที่ไม่ปรากฏในAสิ่งเหล่านี้ควรถูกทิ้งไว้ท้าย ไม่ได้ขยับไปมาเมื่อเทียบกับกันและกัน

กรณีทดสอบ:

A       S               Result
axd     haxuizzxaxduxha aaaxxxxdhuizzuh
a       xyz             xyz
abc     dcba            abcd
il      nmiuplliu       iillnmupu
asdf    qwerty          qwerty

ไบต์ที่น้อยที่สุดจะชนะ!

05AB1E , 4 ไบต์

Rvy†

ลองออนไลน์!

คำอธิบาย

R     # Reverse the alphabet
 vy   # For each letter ...
   †  # Push S with the current letter filtered to the front

Python 3 , 50 47 46 44 ไบต์

-3 ไบต์ด้วย ngn!

-1 ไบต์ขอบคุณ mypetlion

lambda a,s:s.sort(key=lambda c:a.find(c)%27)

ลองออนไลน์!

ใช้สตริงเป็นตัวอักษรและรายการของอักขระเป็นสตริงและเรียงลำดับรายการในตำแหน่ง

%27เพื่อให้แน่ใจว่าถ้าตัวละครไม่ได้อยู่ในตัวอักษรดัชนีกลับทำให้มันหลังจากที่ส่วนที่เหลือของตัวอักษร

Haskell, 42 ไบต์

a#s=[c|c<-a,d<-s,c==d]++[c|c<-s,all(/=c)a]

ลองออนไลน์!

a#s=                     -- take alphabet a and string s
        c<-a             -- for all c in a
             d<-s        --   for all d in s
    [c|       c==d]             keep c if c equals d
   ++                    -- append
    [c|c<-s        ]     --   all c of s
         ,all(/=c)a      --   that are not in a 

Perl 6 ,  55  43 ไบต์

->\A,\S{[~] S.comb.sort:{%(A.comb.antipairs){$_}//∞}}

ลองมัน

->\A,\S{[~] S.comb.sort:{A.index($_)//∞}}

ลองมัน

ขยาย:

-> \A, \S {
  [~]  # reduce using &infix:«~» (shorter than `.join`)

    S.comb.sort: # split into character list and sort by:

      {  # bare block lambda with implicit parameter $_

        A.index( $_ ) # get the position

        //  # if it is undefined (not in `A`)
        ∞   # return Inf instead (so it comes at end of result)
      }
}

Haskell , 40 34 ไบต์

-6ไบต์ขอบคุณมากที่Laikoni

foldr(\c->r(==c)<>r(/=c))
r=filter

ลองออนไลน์!

บรรทัดแรกคือการแสดงออกว่าจะใช้เวลาสองข้อโต้แย้งนี้: Sและ

Stax , 6 ไบต์

{xrINo

เรียกใช้และแก้ไขข้อบกพร่อง

เรียงลำดับตามบล็อกที่ทำสิ่งนี้

• สลับตัวอักษร
• รับดัชนีของตัวละครแต่ละตัวในตัวอักษรที่กลับด้าน ไม่มีผลตอบแทน -1
• ปฏิเสธดัชนี

Python 2 , 38 ไบต์

def f(a,s):s.sort(None,a[::-1].find,1)

aต้องเป็นสตริงsรายการสตริงที่มีความยาว 1. fเรียงลำดับsอยู่ในตำแหน่ง

ลองออนไลน์!

รุ่นอื่น, สตริง I / O, 48 ไบต์

lambda a,s:`sorted(s,None,a[::-1].find,1)`[2::5]

ลองออนไลน์!

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

s.sort(None,a[::-1],1)s.sort(cmp=None,key=a[::-1],reverse=1)เป็นชวเลข

จากเอกสาร :

reverseเป็นค่าบูลีน หากตั้งค่าTrueเป็นองค์ประกอบรายการจะถูกจัดเรียงราวกับว่าการเปรียบเทียบแต่ละรายการกลับ

J , 5 ไบต์

]/:i.

Dyadic verb ใช้ตัวอักษรทางซ้ายและสายอักขระที่จะเรียงทางด้านขวา

i. ค้นหาตัวละครของสตริงในตัวอักษรความยาวของตัวอักษรหากไม่พบ

   'axd' i. 'haxuizzxaxduxha'
3 0 1 3 3 3 3 1 0 1 2 3 1 3 0

/: เรียงลำดับ agrument ซ้ายตามลำดับที่ระบุในหนึ่งขวา

] อาร์กิวเมนต์ rigth (สตริง)

  'haxuizzxaxduxha' /: 3 0 1 3 3 3 3 1 0 1 2 3 1 3 0
aaaxxxxdhuizzuh

ลองออนไลน์!

Python 2 , 35 50 ไบต์

lambda a,s:sorted(s,key=lambda c:-a[::-1].find(c))

ลองออนไลน์!

ใช้aและsเป็นสตริง; ส่งคืนรายการของสตริง singelton

หมายเหตุ: อุ๊ย! ได้รับ 15 ไบต์เพื่อแก้ไข ...

K (ngn / k) , 9 ไบต์

{y@>-x?y}

ลองออนไลน์!

{...}เป็นฟังก์ชันที่มีอาร์กิวเมนต์xและy

x?yพบว่าองค์ประกอบในแต่ละyดัชนีเกิดขึ้นครั้งแรกในx; หากไม่พบองค์ประกอบในxดัชนีนั้นจะถูกพิจารณา0N (-2 ⁶³ )

-ลบดัชนีทั้งหมดยกเว้นว่าจะรักษา0N-s ไว้เหมือนเดิมเพราะ 2 ⁶³ ≡-2 ⁶³ (mod 2 ⁶⁴ )

> ส่งคืนการเรียงลำดับจากมากไปน้อย

y@ดัชนีyกับที่

ถ่าน 13 ไบต์

Ｆθ×ι№ηιΦη¬№θι

ลองออนไลน์! การเชื่อมโยงคือการสร้างรหัสเวอร์ชัน คำอธิบาย:

 θ              First input
Ｆ               Loop over characters
     η          Second input
      ι         Current character
    №           Count matches
   ι            Current character
  ×             Repeat
                Implicitly print
        η       Second input
       Φ        Filter
           θ    First input
            ι   Current character
          №     Count matches
         ¬      Logical not
                Implicitly print non-matching characters

เยลลี่ขนาด 4 ไบต์

fⱮ;ḟ

ลิงก์ dyadic ยอมรับสตริงทางด้านซ้ายและตัวอักษรทางด้านขวา (เป็นรายการของอักขระ) และส่งคืนผลลัพธ์ (เช่นเดียวกับรายการของอักขระ)

ลองออนไลน์!

อย่างไร?

fⱮ;ḟ - Link: string; alphabet                                    e.g. smallnotxl; xl
 Ɱ   - map (for each character in the alphabet):                      1=x; 2=l
f    -   filter keep (keep occurrences of this character from string)   x    lll -> xlll
   ḟ - filter discard (discard all alphabet characters from string)   smanot
  ;  - concatenate                                                    xlllsmanot

APL (Dyalog Unicode) , 5 ไบต์^SBCS

ฟังก์ชั่นคำนำหน้าเงียบโดยไม่ระบุชื่อโดย[string,ordering]ถือเป็นอาร์กิวเมนต์

⍋⍨/⌷⊃

ลองออนไลน์!

... / ลดโดยฟังก์ชั่นต่อไปนี้:

  … ⍨ คือเวอร์ชันย้อนกลับอาร์กิวเมนต์ของฟังก์ชันต่อไปนี้:

  ⍋ เกรดสตริงที่เหมาะสมตามคำสั่งด้านซ้าย (ตัวอักษรหายไปในตอนท้าย)

⌷ ใช้สิ่งนั้นเพื่อจัดทำดัชนีเป็น ...

⊃ องค์ประกอบแรกของการโต้แย้ง (เช่นสตริง)

JavaScript (SpiderMonkey) 50 ไบต์

รับอินพุตในรูปแบบ currying (a)(s)โดยที่aคือสตริงและsคืออาร์เรย์ของอักขระ ส่งคืนอาร์เรย์ของอักขระ

a=>s=>s.sort((b,c)=>(g=c=>-1/a.search(c))(b)-g(c))

ลองออนไลน์!

อย่างไร?

เรากำหนดฟังก์ชันผู้ช่วยg ()เป็น:

c => -1 / a.search(c)

ซึ่งผลตอบแทน:

• 1ถ้าcไม่ได้เป็นของตัวอักษร
• ค่าทศนิยมใน[-Inf, 0)ขึ้นอยู่กับตำแหน่งของcในตัวอักษรเป็นอย่างอื่น (-Inf, -1, -1/2, -1/3, ฯลฯ )

เราจัดเรียงs []โดยการคำนวณg (b) - g (c)สำหรับแต่ละคู่ของอักขระ(b, c) ที่ส่งผ่านไปยังการเรียกกลับของsort ()()

เนื่องจากการดำเนินการเรียงลำดับ ()ใน SpiderMonkey มีความเสถียรตัวละครทั้งหมดของs []ที่ไม่ได้เป็นของตัวอักษรจะถูกย้ายในตอนท้ายตามลำดับของการปรากฏตัวและจะไม่เปลี่ยนแปลงเมื่อมีการเปรียบเทียบกัน

JavaScript (ES6), 61 ไบต์

รับอินพุตในรูปแบบ currying (a)(s)โดยที่aและsเป็นอาร์เรย์ของอักขระ ส่งคืนสตริง

a=>s=>a.map(C=>s=s.filter(c=>c!=C||!(o+=c)),o='')&&o+s.join``

ลองออนไลน์!

R , 69 62 58 ไบต์

function(a,s)c(rep(a,rowSums(outer(a,s,"=="))),s[!s%in%a])

ลองออนไลน์!

อินพุตและเอาต์พุตเป็นเวกเตอร์ของอักขระแต่ละตัว

คำอธิบาย:

function(a,s)c(                              ,           ) #combine:
                   a,                                      #[each char in a
               rep(                                        #each repeated
                     rowSums(               )              #the number of
                             outer(a,s,"==")               #occurrence in s]
                                              s            #with s
                                               [ s%in%a]   #all chars in a
                                                !          #omitted

Brain-Flak (BrainHack) , 118 ไบต์

{({}(<>))<>}{}<>{<>([[]()]<{<>(({})<({}<>[({}<>)]){(<()>)}{}{}>)<>}<>({}<{({}<>)<>}<>>)>[]){({}()<(({}))>)}{}{}<>{}}<>

ลองออนไลน์!

อินพุตเป็นสตริงแรกตามด้วย null ตามด้วยสตริงที่สอง เวอร์ชันที่ใช้ขึ้นบรรทัดใหม่เป็นตัวคั่นแทนเพิ่ม 24 ไบต์:

Brain-Flak , 142 ไบต์

(()){{}(({}(<>))[(()()()()()){}]<>)}{}<>{<>([[]()]<{<>(({})<({}<>[({}<>)]){(<()>)}{}{}>)<>}<>({}<{({}<>)<>}<>>)>[]){({}()<(({}))>)}{}{}<>{}}<>

ลองออนไลน์!

คำอธิบาย

# Move A to other stack reversed
# Zeroes are pushed under each character for later.
# (This is the only part that needs to change in order to use newline as separator.)
{({}(<>))<>}{}<>

# For each character in A, starting at the end:
{

  # Track current length of S.
  <>([[]()]<

    # For each character in S:
    {

      # While keeping character from A
      <>(({})<

        # Move character from S to second stack and push difference
        ({}<>[({}<>)])

        # Delete character if equal
        {(<()>)}{}{}

      >)

    <>}

    # Move S back to first stack while maintaining character from A
    <>({}<{({}<>)<>}<>>)

  # Push difference between old and new lengths of S
  >[])

  # Insert character from A at beginning of S that many times
  {({}()<(({}))>)}{}{}

<>{}}<>

C (gcc) , 97 ไบต์

f(D,d,S,s,i,o)char*D,*S;{
  while(d--){
    for(i=o=s;i--;)S[i]-D[d]?S[--o]=S[i]:0;
    while(o--)S[o]=D[d];
  }
}

ช่องว่างทั้งหมด_{(ช่องว่างและบรรทัดใหม่)}ในรหัสด้านบนมีไว้เพื่อให้สามารถอ่านได้เท่านั้นและควรลบออก

พจนานุกรมถูกส่งผ่านไปในDและมีความยาวdสตริงจะถูกส่งในและมีความยาวS และsioควรละเว้น

ลองออนไลน์!

Pyth ,  9  5 ไบต์

ox+vz

ลองที่นี่!

ox + vz โปรแกรมเต็มรูปแบบ รูปแบบอินพุต: "S" \ n "A"
o จัดเรียงอักขระของ S ตาม (ตัวแปร: N) ...
 x ... ดัชนีของ N ใน ...
  + vz ... A + N

Java 8, 98 ไบต์

a->s->{for(int i=a.length;i-->0;s=s.replaceAll("[^"+a[i]+"]","")+s.replaceAll(a[i],""));return s;}

ลองออนไลน์

คำอธิบาย:

a->s->{       // Method with String-array and String parameters, and String return-type
  for(int i=a.length;i-->0;
              //  Loop backwards over the alphabet
    s=        //   Replace the current `s` with:
      s.replaceAll("[^"+a[i]+"]","") 
              //    All the current characters of `a` in `s`
      +s.replaceAll(a[i],""));
              //    Concatted with everything else
  return s;}  //  Return the modified `s`

Perl 5กับ-pF, 43 ไบต์

$_=<>;print$F[0]x s/@{[shift@F]}//g while@F

ลองออนไลน์!

Prolog (SWI) 136 ไบต์

X/_/[X|_].
X/Y/[Z|R]:-Y\=Z,X/Y/R.
i(_,X,[],[X]).
i(A,X,[Y|R],[X,Y|R]):-X/Y/A.
i(A,X,[Y|R],[Y|S]):-i(A,X,R,S).
A*S*T:-foldl(i(A),S,[],T).

ลองออนไลน์! ตัวอย่างการใช้งาน:

[i,l]*[n,m,i,u,p,l,l,i,u]*S.
S = [i, i, l, l, n, m, u, p, u]

ทำความสะอาด 61 ไบต์

import StdEnv
$a s=[c\\c<-a,k<-s|k==c]++[c\\c<-s|all((<>)c)a]

ลองออนไลน์!

$ :: [Char] [Char] -> [Char]กำหนดฟังก์ชั่น

น่าแปลกใจที่นี่เป็นคำตอบของ Haskellแต่ไม่นานกว่านั้น

เยลลี่ขนาด 7 ไบต์

i@oİ$¥Þ

ลองออนไลน์!

APL + WIN, 12 ไบต์

พรอมต์สำหรับอินพุตหน้าจอของ S แล้ว A:

s[(,⎕)⍋s←,⎕]

ลองออนไลน์! ความอนุเคราะห์จาก Dyalog Classic

PynTree , 13 ไบต์

§yz:ṡzCæf+yxx

ลองออนไลน์!

คำตอบของพอร์ตของโจคิง

คำอธิบาย

§yz:ṡzCæf+yxx  Anonymous lambda
§              lambda  ,
 y                    y
  z                     z
   :                     :
    ṡ                     sorted( ,lambda x:
     z                           z
      C                                     (          )( )
       æf                                    (   ).find
         +                                     +
          y                                   y
           x                                    x
            x                                            x