Penyortiran Array yang ditentukan sebelumnya

26

Memasukkan:

  • Array yang berisi tiga bilangan bulat: 0, 1dan 2dalam urutan apapun (yaitu [2, 0, 1])
  • Dan string dengan panjang> = 2 hanya berisi huruf alfabet (baik huruf kecil dan besar) dan digit (yaitu a1B2c3)

Keluaran:

Berdasarkan array kami mengurutkan dan menampilkan string.
Bagaimana cara kerjanya?

  • Array menunjukkan urutan diutamakan dari a-z, A-Zdan 0-9, yang pertama 0; makhluk kedua 1; dan yang ketiga 2.
  • Karakter individu dari string kemudian dapat dipesan berdasarkan itu.

Contoh:

  • Array: [2, 0, 1]
  • Tali: a1B2c3

Berdasarkan array, kita tahu prioritas pesanan kita 0-9a-zA-Z.
Berdasarkan itu, kita dapat mengkonversi dan output string: 123acB.

Aturan tantangan:

  • Untuk array, Anda dapat memilih untuk menggunakan input 0-diindeks atau 1-diindeks, demikian [3, 1, 2]juga input yang valid jika Anda lebih suka menggunakan array 1-diindeks.
  • String (input dan output) hanya berisi karakter yang valid: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
  • Jika bahasa Anda tidak mendukung array (atau jika Anda memilih untuk), Anda bebas untuk menggunakan string bukan array untuk parameter pertama (yaitu 012, [0,1,2], dll).

Aturan umum:

  • Ini adalah , jadi jawaban tersingkat dalam byte menang.
    Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
  • Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat, program lengkap. Panggilanmu.
  • Celah default tidak diperbolehkan.
  • Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
  • Juga, silakan tambahkan penjelasan jika perlu.

Kasus uji:

[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
Kevin Cruijssen
sumber
Apakah "123"format yang valid untuk parameter pertama?
Mego
Terkait: Meniru pemesanan
xnor
@Mego Ya, mengapa tidak. Itu tidak mempengaruhi bagian utama dari tantangan. Saya telah mengedit pertanyaan saya untuk mencerminkan perubahan. Merasa bebas untuk menggunakan 123, 012, [0,1,2], [0, 1, 2], 0;1;2atau mana yang Anda inginkan.
Kevin Cruijssen

Jawaban:

5

05AB1E , 15 14 12 byte

Kode:

v²žK26ôyèÃ{?

Penjelasan:

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.

Menggunakan pengkodean CP-1252 . Cobalah online! .

Adnan
sumber
Ini bisa 10 byte sekarang dengan menghapus ²dan menggunakan alih-alih 26.
Kevin Cruijssen
8

Python 2, 67 66 byte

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

Uji di Ideone .

Dennis
sumber
7

JavaScript (ES6), 87 byte

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

Jika array input memberi urutan, alih-alih diutamakan, dari tiga rentang (ini hanya membuat perbedaan untuk [1, 2, 0]dan [2, 1, 0]yang efeknya ditukar) maka ini akan bekerja untuk 80 byte:

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

Saya salah membaca pertanyaan dan masih mendapatkan 7 suara positif dengan ini. Jangan ragu untuk menghapus upvotes Anda dan berikan ke @CharlieWynn sebagai gantinya, yang datang dengan koreksi terbaik untuk pendekatan saya.

(a,s)=>a.map(n=>s.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``
Neil
sumber
3
Ooh, solusi yang sangat menarik! Saya sedang memikirkan jawaban ES6 yang berbeda untuk menggunakan Array.sortparameter fungsi opsional tapi ini jauh lebih baik.
charredgrass
1
Saya sangat suka solusi ini, tetapi saya pikir itu gagal tes 2, 3 dan mungkin yang lain. Saya kira Anda harus mengurutkan masing-masing dari tiga segmen?
Charlie Wynn
@CharlieWynn Maaf, saya pasti salah membaca pertanyaan. (Ini kesalahan umum saya.)
Neil
@ Neil, saya tidak berpikir pertanyaan itu membuatnya sangat jelas untuk mengurutkan array, hanya memperhatikan kasus-kasus uji tampaknya memiliki fitur itu.
Charlie Wynn
@CharlieWynn Sebagian besar kasus uji tampaknya sudah diurutkan dengan bagian lebih rendah / atas / numerik ...
Neil
5

Jelly , 13 byte

2_ịØWs26¤Ff@€

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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.
Dennis
sumber
5

Pyth, 17 16 15 byte

s@RSz@L[GrG1`UT

Suite uji.

       [          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

Terima kasih kepada @FryAmTheEggman untuk byte dan @Jakube untuk yang lain!

Gagang pintu
sumber
Anda bisa menggunakan 'UTbukan s'MT.
Jakube
@ Jakube Saya menggunakan backtick, bukan kutipan tunggal. Tetapi 'UTadalah kesalahan, dan `UTtidak menghasilkan string yang sama.
Gagang pintu
Ya, maksud saya backtick. Tapi backtick sulit ditulis di komentar. Ya, itu menghasilkan string yang berbeda, tetapi seharusnya tidak masalah. String yang dihasilkan berisi semua digit dan tanpa huruf.
Jakube
@ Jakube Oh, begitu. Itu pintar; Terima kasih!
Gagang pintu
5

Javascript es6 77 byte

(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"
Charlie Wynn
sumber
Mencuri ide susunan regex Neil yang sangat rapi
Charlie Wynn
Dengan menambahkan ?s ke setiap regex, ini memastikan bahwa pertandingan mengembalikan hasil (sebagian besar string kosong, tetapi mereka tetap menghilang), menghindari (||[]), sehingga menghemat 3 byte secara keseluruhan.
Neil
@Neil luar biasa, terima kasih .. Saya tidak yakin mengapa Anda memilikinya di hati Anda: P
Charlie Wynn
4

TSQL, 199 191 byte

Golf:

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 @

Tidak Disatukan:

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 @

Biola

t-clausen.dk
sumber
3

APLX , 19 byte

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

⎕a⎕A⎕D digit atas bawah

(... )[a]atur ulang menurut larik a

meratakan

(... )⍋smenurut bahwa "abjad", memberikan indeks yang akan memilah-string yang s

s[... ]gunakan itu untuk menyusun ulang s

Adám
sumber
Sayang sekali APL Dyalog tidak memiliki ⎕a dan terjemahan huruf besar ke huruf kecil membutuhkan banyak byte dalam solusi :-) Bukannya saya tidak menyarankan untuk Dyalog APL untuk memasukkan ⎕a mengingat kegunaannya akan cukup banyak berkurang untuk tantangan kode-golf, sejauh yang saya tahu.
lstefano
@ lstefano Saya tidak suka ⎕a, karena itu adalah nama quad case-sensitive. Jauh lebih baik (untuk bermain golf dan secara umum) untuk apa saya melobi; untuk mendapatkan dan melipat kasing pada data karakter, seperti di K. Kemudian kita akan memiliki ⌊⎕Aalih - alih ⎕a.
Adám
2

Python 2, 121 Bytes

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

Clojure, 74 byte

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

Untuk setiap nilai dalam daftar pertama, dapatkan regex yang sesuai dan terapkan ke string input. Hasilnya adalah daftar daftar simbol yang cocok dengan regex. Kemudian mengurutkan masing-masing dan menggabungkan hasilnya menjadi satu daftar dan mengubahnya menjadi string.

Anda dapat melihatnya online di sini: https://ideone.com/dqAkxg

cliffroot
sumber
2

Retina , 43 39 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1. Linefeed tambahan sangat penting.

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

Input diharapkan menjadi urutan pengurutan sebagai daftar berbasis nol tanpa pembatas pada baris pertama, dan string yang akan diurutkan pada baris kedua, misalnya

120
fOo42BaR

Cobalah online!

Penjelasan

Saya akan menggunakan contoh input di atas untuk memandu Anda melalui kode:

120
fOo42BaR

Tahap 1: Substitusi

2=`.
!$&"

Regex itu sendiri adil .(cocok dengan karakter non-linefeed apa pun), yang dikelilingi dengan !...". Namun, itu 2=adalah batas yang memberitahu Retina untuk menerapkan substitusi hanya pada pertandingan kedua regex. Jadi kami mendapatkan ini:

1!2"0
fOo42BaR

Tahap 2: Transliterasi

T04`¶d`#^@%

Tahap transliterasi hanya melakukan substitusi karakter-demi-karakter. Ini mewakili umpan baris dan ddiperluas ke 0123456789(meskipun kami dapat mengabaikan semua digit setelah 2). Itu berarti, transliterasi ini sesuai dengan pemetaan berikut:

¶012
#^@%

Di 04depan adalah dua batas, yang bersama-sama menunjukkan bahwa hanya empat karakter pertama dari set ini yang harus ditransliterasi. Itu adalah digit di baris pertama, serta baris yang memisahkan kedua baris, jadi kita dapatkan ini:

@!%"^#fOo42BaR

Di bagian depan string sekarang kita punya tiga pasang karakter ini:

@!
%"
^#

Perhatikan bahwa karakter kedua dari pasangan hanya dalam urutan ASCII normal (dan akan selalu sama). Kami akan menggunakan ini nanti untuk mengurutkan grup karakter di input utama ke dalam urutan yang diperlukan.

Karakter pertama sedikit lebih menarik: signifikansinya adalah yang %datang sebelum digit pada tabel ASCII, @datang sebelum huruf besar (tetapi setelah angka), dan ^datang sebelum huruf kecil (tetapi setelah huruf besar). Ini akan membantu kami mengelompokkan penanda posisi (yaitu karakter kedua di setiap pasangan) dengan set karakter yang tepat.

Tahap 3: Sortir

O`\W?.

Ini adalah semacam tahapan sederhana. Ini cocok dengan dua karakter jika yang pertama bukan karakter kata (dengan demikian cocok dengan ketiga pasangan yang baru saja saya bicarakan) atau satu karakter sebaliknya (cocok dengan masing-masing karakter dari input utama secara individual), dan mengurutkan string tersebut. Ini memiliki dua tujuan: itu membawa karakter dalam setiap kelompok dalam urutan yang benar (dan karena penyortiran stabil, urutan ini tidak akan kacau di tahap berikutnya), dan karena %@^spidol, itu memasukkan pasangan dalam posisi yang tepat:

%"24@!BOR^#afo

Tahap 4: Sortir

O`.\w+

Tahap ini mengurutkan semua kecocokan dari .\w+regex yang, karena keserakahan, cocok dengan satu penanda posisi (yaitu salah satu dari !"#) bersama dengan semua karakter kata setelahnya. Yaitu, ini mengurutkan tiga string ini, yang urutannya ditentukan hanya oleh karakter marker:

"24! BOR #afo

Sementara ini mengacak di sekitar penanda tersebut (sambil meninggalkan tiga penanda lainnya di tempat), yang paling penting itu membawa angka dan huruf dalam urutan yang benar:

%!BOR@"24^#afo

Tahap 5: Substitusi

\W

Yang tersisa hanyalah sedikit pembersihan, tempat kami menghapus semua penanda dengan mencocokkannya dan menggantinya dengan apa pun.

Martin Ender
sumber
2

JavaScript (ES6), 65

Catatan: pesanan ASCII 'alami' adalah 0-9, AZ, az, yang merupakan kebalikan dari OP 0,1,2. Begitu

  • memesan string menambahkan karakter yang tidak valid untuk memisahkan menjalankan
  • membaginya dalam 3 segmen - masing-masing menandai karakter yang tidak valid
  • dapatkan segmen satu per satu dalam urutan yang diminta
  • berkumpul kembali
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
sumber
2

Haskell, 62 63 byte

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

Contoh penggunaan: "cD12ab" # [2,0,1]-> "12abcD".

Bagaimana itu bekerja:

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

Sunting: @Christian Sievers menemukan bug. Terima kasih! Diperbaiki untuk 1 byte tambahan.

nimi
sumber
Bagaimana dengan karakter yang terjadi lebih dari satu kali?
Christian Sievers
@ChristianSievers: Anda benar, itu bug. Tetap. Terimakasih!
nimi
2

Stax , 15 byte

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

Jalankan dan debug secara online

Pengiriman 15 byte ini dikemas ke dalam varian set karakter CP437. Representasi ascii yang sesuai membutuhkan waktu 18 byte:

EVlVd+26/s@:fs{[Io

Cukup yakin itu bisa dipangkas lebih lanjut.

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+bisa juga VLA|(, yang dibiarkan berputar 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZoleh sepuluh elemen. Seluruh kode juga bisa VlVd+26/,e@:f,{[Io, yang membaca tumpukan input dua kali alih-alih membaca semuanya pada awal hingga tumpukan utama, dan menggunakan format input yang berbeda (lebih tradisional), seperti yang ditunjukkan dalam ini .

Weijun Zhou
sumber
1

Dyalog APL , 22 byte

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

(819⌶⎕A) lipat huruf besar ke kecil

()⎕A⎕D[a]Digit atas yang lebih rendah disusun ulang menurut larik a

meratakan

s⍋⍨untuk string s , dapatkan indeks yang akan mengurutkan s menurut yang "alfabet"

s[... ]gunakan itu untuk menyusun ulang s

Adám
sumber
mmm .... 819⌶ hanya ada di versi unicode dari Dyalog APL. Jadi saya akan menduga bahwa jumlah byte harus dikalikan dengan 2 karena input secara efektif terdiri dari titik masuk Unicode. Atau pemahaman saya tentang penghitungan byte untuk pengiriman APL salah?
lstefano
@ lstefano Edisi Unicode dapat memuat ruang kerja Klasik, bukan?
Adám
Itu licik ;-)
lstefano
1

PowerShell v2 +, 107 byte

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

Saya sedang mengeksplorasi algoritma menggunakan regex, tetapi sejauh ini semuanya tampak lebih panjang.

Mengambil input sebagai array eksplisit $n(lihat contoh di bawah) dan string $syang langsung dilemparkan ke array char. Kami kemudian membangun tiga elemen dari array dinamis baru, masing-masingnya dienkapsulasi dengan -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Yang pertama kita ambil $sdan jalankan Sort-Object. Untungnya, karena kita sudah menjadikannya sebagai char-array, ini merupakan penyortiran case-sensitive. Itu akan disimpan kembali ke $sdan kemudian disalurkan ke Where-Objectdengan klausa lebih besar dari 97(yaitu, huruf kecil ASCII a-z). Yang kedua adalah untukA-Z dan yang ketiga untuk 0-9.

Jadi kita sekarang memiliki array string, di mana setiap string terdiri dari satu dari tiga tipe karakter dan diurutkan. Kami mengirisnya dengan [$n]lalu-join hasilnya bersama-sama untuk membentuk string hasil akhir kami. Yang tersisa pada pipa dan pencetakan tersirat.

Uji Kasus

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

Ruby, 56 byte

Porting dari jawaban @Dennis.

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

Solusi 58 byte alternatif yang saya sukai lebih baik, terinspirasi oleh @Neil dan sedikit dimodifikasi dari jawabannya.

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

Coba salah satu versi online! (versi komentar-keluar adalah solusi alternatif)

Nilai Tinta
sumber
1

Kode mesin x86 32-bit, 70 byte

Dalam hex:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Prosedur ini mengharapkan urutan penyortiran kelas karakter menjadi string 3-char (0..2) NULL ESIdan string untuk diurutkanEDI . Penyortiran dilakukan di tempat menggunakan versi penyortiran gelembung yang sangat sub-optimal (berdasarkan kinerja).

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

Emacs Lisp, 183 byte

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

Sedikit lebih pendek dari Jawa ...

Tuan Yuuma
sumber
1

Clojure, 77 byte

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

Tidak sesingkat yang re-seqberbasis, dan saya tidak tahu bagaimana mengekspresikan " (apply str(mapcat sort(map(...))))" itu dalam ruang yang lebih sedikit.group-bymembuat hash-peta yang dapat digunakan sebagai fungsi, ketika ditanya dengan ingeger antara 0 dan 2 mengembalikan grup yang sesuai, ini memerintahkan tiga kelas karakter yang berbeda.

Ini akan lebih ringkas daripada re-seqsolusinya jika ada lebih banyak kelas karakter untuk ditangani karena ini hanya membutuhkan 5 karakter tambahan / grup 57 1,daripada 8 untuk ekspresi seperti #"[a-z]".

NikoNyrh
sumber
1

Python 2, 140 117 101 100 99 byte

Semua orang berkata, "Ewww!". Setidaknya itu bisa dibaca ... batuk bukan batuk

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]

Cobalah online

mbomb007
sumber
1

R , 101 byte

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

Membuat vektor dengan az, AZ dan 0-9 dalam urutan yang diberikan dan menata ulang karakter dari string input agar sesuai dengan pemesanan ini.

Cobalah online!

Robert Hacken
sumber
0

J, 40 byte

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

Java 8, 221 212 193 156 byte

Tentu saja saya harus mencoba menjawab tantangan saya sendiri. :) (Dan seperti biasa di Jawa.)

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());}

-28 byte disimpan berkat @cliffroot .

Penjelasan:

Coba di sini.

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
Kevin Cruijssen
sumber
1
Anda dapat mengganti regexps Anda dengan [^a-z] [^A-Z] [^0-9]dan Anda dapat menggunakan getBytes()bukannyatoCharArray()
cliffroot
@cliffroot Terima kasih. Saya sangat buruk di regex, tetapi tidak menggunakan ^(tidak) cukup bodoh ..;)
Kevin Cruijssen
1
menghapus replaceAllpanggilan berulangString 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;}
cliffroot