Hintergrund

In C gibt es eine Funktion zum Parsen von Befehlszeilenargumenten : getopt.

Getopt verwendet das Argument count ( argc), die Argumentliste ( argv) und eine Zeichenfolge, die die Optionen darstellt, die das Programm ausführen soll ( optstring).

Die Optionszeichenfolge ( optstring) besteht aus einer Reihe von Optionszeichen, gefolgt von einem Doppelpunkt (für eine Option, für die ein Argument erforderlich ist), zwei Doppelpunkten (für eine Option mit einem optionalen Argument) oder null Doppelpunkten (für eine Option ohne Argument).

Beispiel: Für das neue Widget des Unternehmens kann die folgende Optionszeichenfolge verwendet werden.

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

Aber das sieht schrecklich aus! Die Optionen sind alle gemischt! Diese Optionszeichenfolge würde viel besser aussehen, wenn sie sortiert wäre:

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

Spezifikationen

• Die Eingabe ist eine Zeichenfolge, die dem regulären Ausdruck entspricht ([A-Za-z]:{0,2})+

• Sie sollten die Eingabe als Zeichenfolge oder Liste von Zeichen verwenden.

• Sie sollten die Zeichenfolge nach der unten beschriebenen Methode sortiert ausgeben.

• Sie müssen keine leeren Eingaben verarbeiten.

• Sie müssen Eingaben nicht mit wiederholten Optionen desselben Typs verarbeiten ( "aa"ist ungültig, aber "aa:a::"gültig).

Sortiermethode

In der sortierten Optionszeichenfolge:

• Die Zeichen, gefolgt von zwei Doppelpunkten, stehen alphabetisch sortiert an erster Stelle mit Großbuchstaben vor den jeweiligen Kleinbuchstaben (dh "aBb", nicht "Bab").

• Dann sind die Zeichen mit einem Doppelpunkt, alphabetisch sortiert, mit Großbuchstaben vor ihren jeweiligen Kleinbuchstaben.

• Zuletzt sind die Zeichen ohne Doppelpunkt alphabetisch sortiert mit Großbuchstaben vor den jeweiligen Kleinbuchstaben.

Regeln

• Standardlücken sind verboten.

Wertung

Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes in jeder Sprache.

Beispiele

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

Langer Testfall (312 Zeichen)

Invaid-Eingaben (müssen Sie nicht verarbeiten):

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

Schale , 11 Bytes

ΣÖom_↔Oġλ¬√

Probieren Sie es online aus!

Erläuterung

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

Netzhaut , 47 Bytes

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

Probieren Sie es online aus!

Der schwierigste Teil war das Sortieren der Buchstaben, da die Funktion "Sortieren nach" von Retina keine Sortierung ohne Berücksichtigung der Groß- und Kleinschreibung enthält (standardmäßig werden also die Großbuchstaben vor allen Kleinbuchstaben sortiert ). Um dies zu umgehen, musste ich von jedem Zeichen eine Kopie in Kleinbuchstaben einfügen, um die Sortierung durchzuführen, und sie dann wieder entfernen.

Python 2 , 100 90 Bytes

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

Probieren Sie es online aus!

Gelee , 14 Bytes

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

Probieren Sie es online aus!

Volles Programm.

Japt , 17 16 Bytes

f".:*" ñ_iZw vÃq

Testen Sie es online!

Wie es funktioniert

Angenommen, die Eingabezeichenfolge lautet v:vg::G:G::o:. Der erste Teil des Codes f".:*"findet alle Übereinstimmungen des regulären Ausdrucks /.:*/g, der einem Zeichen gefolgt von einer beliebigen Anzahl von Doppelpunkten entspricht. Dies teilt die Eingabe in[v:, v, g::, G:, G::, o:].

Die ñMethode in einem Array sortiert jedes Array so, als ob bestimmte Änderungen angewendet würden, ohne sie tatsächlich anzuwenden (wie sorted(array, key=<whatever>)in Python). Also müssen wir sortieren:

• Doppelpunkte vor allem anderen;
• Ein-Doppelpunkte nach Doppel-Doppelpunkten, aber vor Nicht-Doppelpunkten;
• Buchstaben in alphabetischer Reihenfolge; und schlussendlich
• Großbuchstaben vor Kleinbuchstaben.

Z{ZiZéJ v} ist der kürzeste Weg, den ich finden könnte, um dies zu tun:

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

Dies ist am einfachsten anhand einiger Beispiele zu verstehen:

         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:

Die ursprünglichen Werte werden dann nach diesen Schlüsseln lexikografisch sortiert. Das Ergebnis ist, dass ::gG::nach vorne sortiert wird ::gg::, und so weiter, was uns gibt [G::, g::, G:, o:, v:, v], was dann mit verbunden qund ausgegeben wird.

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 Bytes

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

Probieren Sie es online aus!

Haskell , 124 Bytes

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

Probieren Sie es online aus!

Bash, 232 213 Bytes

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

Probieren Sie es online aus

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

Probieren Sie es online aus!

Ungolfed:

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

Die Grundidee besteht darin, alle 156 möglichen Optionen zu durchlaufen und ihre Existenz zu überprüfen. Wenn gefunden, an die Ausgabe anhängen und aus der Eingabe entfernen.