Lý lịch

Trong C, có một hàm giúp phân tích các đối số dòng lệnh : getopt.

Getopt lấy số đối số ( argc), danh sách đối số ( argv) và một chuỗi đại diện cho các tùy chọn mà chương trình sẽ lấy ( optstring).

Chuỗi tùy chọn ( optstring) là một chuỗi các ký tự tùy chọn được theo sau bởi một dấu hai chấm (đối với tùy chọn yêu cầu đối số), hai dấu hai chấm (đối với tùy chọn có đối số tùy chọn) hoặc dấu hai chấm (đối với tùy chọn không có đối số).

Ví dụ: người ta có thể sử dụng chuỗi tùy chọn sau cho tiện ích mới của công ty họ.

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

Nhưng trông thật kinh khủng! Các tùy chọn được trộn lẫn với nhau! Chuỗi tùy chọn này sẽ trông tốt hơn nhiều nếu được sắp xếp:

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

Thông số kỹ thuật

• Đầu vào sẽ là một chuỗi khớp với biểu thức chính quy ([A-Za-z]:{0,2})+

• Bạn nên lấy đầu vào dưới dạng một chuỗi hoặc danh sách các ký tự.

• Bạn nên xuất chuỗi được sắp xếp theo phương pháp chi tiết bên dưới.

• Bạn không cần phải xử lý đầu vào trống.

• Bạn không cần xử lý đầu vào với các tùy chọn lặp lại cùng loại ( "aa"không hợp lệ, nhưng "aa:a::"hợp lệ).

Phương pháp sắp xếp

Trong chuỗi tùy chọn đã sắp xếp:

• Các ký tự theo sau bởi hai dấu hai chấm xuất hiện trước, được sắp xếp theo thứ tự abc, với các chữ cái viết hoa trước các chữ cái viết thường tương ứng của chúng (tức là "aBb", không phải "Bab").

• Sau đó là các ký tự có một dấu hai chấm, được sắp xếp theo thứ tự abc, với các chữ cái viết hoa trước các chữ cái viết thường tương ứng của chúng.

• Cuối cùng là các ký tự không có dấu hai chấm, được sắp xếp theo thứ tự abc, với các chữ cái viết hoa trước các chữ cái viết thường tương ứng của chúng.

Quy tắc

• Lỗ hổng tiêu chuẩn bị cấm.

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất tính bằng byte trong mỗi ngôn ngữ sẽ thắng.

Ví dụ

# "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"

Trường hợp thử nghiệm dài (312 ký tự)

Đầu vào được trả tiền (bạn không phải xử lý):

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

Husk , 11 byte

ΣÖom_↔Oġλ¬√

Hãy thử trực tuyến!

Giải trình

ΣÖ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

Võng mạc , 47 byte

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

Hãy thử trực tuyến!

Phần khó nhất thực sự là sắp xếp các chữ cái, bởi vì tính năng "sắp xếp theo" của Retina không có loại không phân biệt chữ hoa chữ thường (vì vậy theo mặc định, nó sắp xếp các chữ cái in hoa phía trước tất cả các chữ cái viết thường). Để giải quyết vấn đề này, tôi đã phải chèn một bản sao chữ thường của mỗi ký tự để thực hiện sắp xếp và sau đó loại bỏ nó một lần nữa.

Python 2 , 100 90 byte

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

Hãy thử trực tuyến!

Thạch , 14 byte

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

Hãy thử trực tuyến!

Chương trình đầy đủ.

Japt , 17 16 byte

f".:*" ñ_iZw vÃq

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

Nói chuỗi đầu vào là v:vg::G:G::o:. Phần đầu tiên của mã, f".:*"tìm thấy tất cả các kết quả khớp của biểu thức chính /.:*/g, khớp với một ký tự theo sau bởi bất kỳ số lượng dấu hai chấm nào. Điều này phân chia đầu vào thành[v:, v, g::, G:, G::, o:].

Các ñphương pháp trên một mảng phân loại từng mảng như thể thay đổi nhất định đã được áp dụng, mà không thực sự áp dụng chúng (như sorted(array, key=<whatever>)trong Python). Vì vậy, chúng ta cần sắp xếp:

• dấu hai chấm trước mọi thứ khác;
• dấu hai chấm đơn sau dấu hai chấm, nhưng trước dấu hai chấm;
• chữ cái theo thứ tự chữ cái của họ; và cuối cùng
• chữ in hoa trước chữ thường.

Z{ZiZéJ v} là cách ngắn nhất tôi có thể tìm thấy để làm điều này:

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

Điều này dễ hiểu nhất với một số ví dụ:

         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:

Các giá trị ban đầu sau đó được sắp xếp theo từ vựng theo các phím này. Kết quả là ::gG::được sắp xếp ra phía trước, sau đó ::gg::, v.v., cho chúng ta [G::, g::, G:, o:, v:, v], sau đó được nối với qvà xuất ra.

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

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

thử trực tuyến

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

Hãy thử trực tuyến!

Ung dung:

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

Ý tưởng cơ bản là lặp đi lặp lại trên tất cả 156 tùy chọn có thể và kiểm tra sự tồn tại của chúng. Nếu tìm thấy, nối vào đầu ra và xóa khỏi đầu vào.