Latar Belakang

Dalam C, ada fungsi untuk argumen command-line membantu parse: getopt.

Getopt mengambil jumlah argumen ( argc), daftar argumen ( argv), dan string yang mewakili opsi yang harus diambil oleh program (optstring ).

String pilihan (optstring ) adalah serangkaian karakter opsi yang masing-masing diikuti oleh satu titik dua (untuk opsi yang membutuhkan argumen), dua titik dua (untuk opsi dengan argumen opsional), atau nol titik dua (untuk opsi tanpa argumen).

Sebagai contoh: seseorang dapat menggunakan string opsi berikut untuk widget baru perusahaan mereka.

"v::x:hy:S:G::dns:f::"

Tapi itu terlihat mengerikan! Pilihannya semua dicampur bersama! String opsi ini akan terlihat jauh lebih baik jika diurutkan:

"f::G::v::S:s:x:y:dhn"

Spesifikasi

• Input akan berupa string yang cocok dengan ekspresi reguler ([A-Za-z]:{0,2})+

• Anda harus mengambil input sebagai string atau daftar karakter.

• Anda harus menampilkan string yang diurutkan dengan metode yang dirinci di bawah ini.

• Anda tidak perlu menangani input kosong.

• Anda tidak perlu menangani input dengan opsi berulang dari jenis yang sama ( "aa"tidak valid, tetapi"aa:a::" valid).

Metode Penyortiran

Dalam string opsi yang diurutkan:

• Karakter diikuti oleh dua titik dua didahulukan, disortir berdasarkan abjad, dengan huruf besar sebelum huruf kecil masing-masing (yaitu "aBb", bukan "Bab").

• Kemudian adalah karakter dengan satu titik dua, diurutkan berdasarkan abjad, dengan huruf besar sebelum huruf kecil masing-masing.

• Terakhir adalah karakter tanpa titik dua, diurutkan berdasarkan abjad, dengan huruf besar sebelum huruf kecil masing-masing.

Aturan

• Celah Standar dilarang.

Mencetak gol

Ini adalah kode-golf , jadi jawaban terpendek dalam byte di setiap bahasa akan menang.

Contohnya

# "input" => "output"
"v::x:hy:S:G::dns:f::" => "f::G::v::S:s:x:y:dhn"
"aa:a::" => "a::a:a"
"B:" => "B:"
"Confusio:n::" => "n::o:Cfinosu"
"Confusio:n:" => "n:o:Cfinosu"
"m:qW:X:xc:vViI" => "c:m:W:X:IiqVvx"
"V:omo:V" => "o:V:moV"
"agg:ra:va::ting::" => "a::g::a:g:aginrtv"
"input" => "inptu"

Kasing panjang (312 karakter)

Input Tidak Valid (Anda tidak harus menangani):

"gg" (duplicated option)
"" (empty string)
":w:" (first colon isn't after a character)
"x:y:0:fhn" ('0' is not alphabetic)
"A:::" (3 colons is invalid)

Sekam , 11 byte

ΣÖom_↔Oġλ¬√

Cobalah online!

Penjelasan

ΣÖom_↔Oġλ¬√  Implicit input, say "kH::r:R:Hk:"
       ġ     Split between characters for which this gives a falsy result:
        λ      Take two arguments, ignore the first.
          √    Is the second argument a letter?
         ¬     Negate.
             Now we have the options: ["k","H::","r:","R:","H","k:"]
      O      Sort: ["H","H::","R:","k","k:","r:"]
 Ö           Sort by
     ↔       reversing and
  om_        converting everything to lowercase: ["H::","k:","R:","r:","H","k"]
Σ            Concatenate: H::k:R:r:Hk

Retina , 47 byte

.
$&$&
T01`L`l`..
O^`\w.:*
.(.)
$1
O$^`\w:*
$.&

Cobalah online!

Bagian tersulit sebenarnya adalah pengurutan huruf, karena fitur "sort-by" Retina tidak memiliki jenis case-insensitive (jadi secara default ia mengurutkan huruf besar di depan semua huruf kecil). Untuk mengatasi ini, saya harus memasukkan salinan huruf kecil dari setiap karakter untuk melakukan penyortiran dan kemudian menyingkirkannya lagi.

Python 2 , 100 90 byte

lambda s:''.join(sorted(re.findall('.:*',s),key=lambda s:(-len(s),s.lower(),s)))
import re

Cobalah online!

Jelly , 14 byte

n”:œṗ⁸ṢŒuÞṚLÞṚ

Cobalah online!

Program lengkap.

Japt , 17 16 byte

f".:*" ñ_iZw vÃq

Uji secara online!

Bagaimana itu bekerja

Katakanlah string input v:vg::G:G::o:. Bagian pertama dari kode,, f".:*"menemukan semua kecocokan dari regex /.:*/g, yang cocok dengan karakter yang diikuti oleh sejumlah titik dua. Ini membagi input menjadi[v:, v, g::, G:, G::, o:].

The ñmetode pada array macam setiap array seakan perubahan tertentu diterapkan, tanpa benar-benar menerapkan mereka (seperti sorted(array, key=<whatever>)di Python). Jadi kita perlu mengurutkan:

• titik dua sebelum hal-hal lain;
• satu-titik dua setelah dua titik, tetapi sebelum tanpa titik dua;
• surat dalam urutan abjad; dan akhirnya
• huruf besar sebelum huruf kecil.

Z{ZiZéJ v} adalah cara terpendek yang dapat saya temukan untuk melakukan ini:

  Zw     Reverse Z.
     v   Convert to lowercase.
Zi       Insert this at the beginning of Z.

Ini paling mudah dipahami dengan beberapa contoh:

         v:   v  g::    G:   G::    o:
  Zw     :v   v  ::g    :G   ::G    :o
     v   :v   v  ::g    :g   ::g    :o
Zi       :vv: vv ::gg:: :gG: ::gG:: :oo:

Nilai asli kemudian diurutkan secara leksikografis oleh tombol-tombol ini. Hasilnya adalah yang ::gG::diurutkan ke depan, lalu ::gg::, dan seterusnya, memberi kita [G::, g::, G:, o:, v:, v], yang kemudian bergabung dengan qdan dikeluarkan.

JavaScript (ES6), 93 byte

f=
s=>s.match(/\w:*/g).sort((a,b)=>b.length-a.length||parseInt(a,36)-parseInt(b,36)||a>b).join``

<input oninput=o.textContent=this.value&&f(this.value)><pre id=o>

Perl 5 , 69 + 1 ( -n) = 70 byte

say sort{$b=~y///c<=>length$a||($"=lc$a)cmp lc$b||1-2*($"ne$a)}/.:*/g

Cobalah online!

Haskell , 124 byte

import Data.List
import Data.Char
s(c:x)|(l,r)<-span(==':')x=(-length l,toLower c,c:l):s r;s _=[]
t(_,_,x)=x
f=(t=<<).sort.s

Cobalah online!

Bash, 232 213 byte

s(){ s=${1#?} c=${1%$s} o=${s%%[^:]*} s=${s#$o} o=$c$o;};
p()(s $1;l= g= p=$o d=$c;[[ $o ]]&&(while s $s;[[ $o ]];do
(((x=${#o}-${#p},y=36#$d-36#$c,x?x:y?y:62#$c-62#$d)>0))&&g+=$o||l+=$o;done;echo `p $g`$p`p $l`))

coba online

C # (.NET Core) , 152 byte

s=>{var o="";for(var d=":::";d!="";){d=d.Substring(1);for(var c='@';c!=90;o+=s.IndexOf(c+d)>=0?c+d:"",s=s.Replace(c+d,""),c^=' ')if(c<97)c++;}return o;}

Cobalah online!

Tidak Disatukan:

s => { 
    var o = ""; 
    for (var d = ":::"; d != "";) { 
        d = d.Substring(1); 
        for (
            var c = '@'; 
            c != 90; 
            o += s.IndexOf(c + d) >= 0 ? c + d : "", s = s.Replace(c + d, ""), c ^= ' '
        ) if (c < 97) c++; 
    } 
    return o; 
}

Ide dasarnya adalah untuk mengulangi semua 156 opsi yang mungkin dan memeriksa keberadaannya. Jika ditemukan, tambahkan ke output, dan hapus dari input.