Die Leute auf dieser Seite lieben es wirklich, ihre Beitragstitel zu verschönern ...

Stewie's sequence: + * - / + * - /

Wenn dieser Titel jedoch in die Seiten-URL aufgenommen werden muss, wird dies vereinfacht:

stewies-sequence

Die Herausforderung

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu erstellen, die anhand eines Strings, der einen Beitragstitel darstellt, die "URL-freundliche" Konvertierung ausgibt / zurückgibt.

Der Algorithmus ist:

• In Kleinbuchstaben konvertieren (falls zutreffend)
• Ersetzen Sie jedes Leerzeichen ( ), jeden Punkt ( .), jedes Komma ( ,) oder jeden Schrägstrich ( /) durch einen Bindestrich ( -).
• Entfernen Sie alle nicht alphanumerischen Zeichen mit Ausnahme der Bindestriche.
• Minimieren Sie Gruppen benachbarter Bindestriche ( a---b -> a-b) und entfernen Sie alle vorangestellten / nachfolgenden Bindestriche .

_{Bitte beachten Sie, dass dieser Algorithmus eine Vereinfachung darstellt und möglicherweise nicht immer die gleichen Ergebnisse wie die eigentliche Methode der Site liefert.}

Regeln

• Sie können diese Eingabe annehmen:
  • Wird nicht leer sein.
  • Enthält mindestens ein alphanumerisches Zeichen.
  • Enthält nur Zeichen im ASCII-Bereich 32-126 (druckbar)
• Vollständige Programme oder Funktionen sind zulässig.
• Ein Builtin, das die genaue Aufgabenspezifikation ausführt, ist nicht zulässig.
• Das ist Code-Golf , also gewinnt die kürzeste Lösung (in Bytes)!

Testfälle

Die meisten Beiträge auf dieser Website dienen als Test, aber hier ist eine praktische Liste:

Loading... Forever       -> loading-forever
N(e(s(t))) a string      -> nest-a-string
"Hello, World!"          -> hello-world
URL-Friendly titles      -> url-friendly-titles

C.U.S.R.S                -> c-u-s-r-s
1+2+3+4+...+n = -1/12?   -> 1234-n-1-12
How can I use cmp(a,b)   -> how-can-i-use-cmpa-b

Einige längere ...

Export The $PATH Variable, Line-By-Line   -> export-the-path-variable-line-by-line
Do n and n^3 have the same set of digits? -> do-n-and-n3-have-the-same-set-of-digits
Quine Anagrams! (Cops' Thread)            -> quine-anagrams-cops-thread
The Golfer Adventure - Chapter 1          -> the-golfer-adventure-chapter-1
Bootloader golf: Brainf***                -> bootloader-golf-brainf

Und ein paar Beispiele zur Überprüfung von Randfällen (Sie können gerne weitere vorschlagen):

0123   ->   0123
a a1   ->   a-a1
2-1=1  ->   2-11

Retina, 33-31 Bytes

T`L`l
[^a-z ,-9]+

\W+
-
^-|-$

(Das Programm hat einen abschließenden Zeilenumbruch)

Ich bin mir nicht sicher, ob ich mehr daraus machen kann. Dies sollte alles abdecken. Kam ähnlich wie Mama Fun Rolls. Weitere 33-Byte-Version mit rekursiven regulären Ausdrücken

Probieren Sie es online!

Erläuterung

T`L`l

Diese Leitung ist einfach, es wandelt von in Kleinbuchstaben T ransliterating A-Z( L) bis a-z( l, Kleinbuchstaben).

Diese Phase ist einfach, sie beseitigt im Wesentlichen alle nicht benötigten Charaktere, um uns später viel Ärger zu ersparen

[^a-z ,-9]+

[^a-z ,-9] Stimmt mit jedem Zeichen überein, das NICHT ist:

• a-z: Kleinbuchstaben (gesamte Zeichenfolge ist wegen des vorherigen Elements in Kleinbuchstaben geschrieben)
• : Raumzeichen
• ,-9Dies ist der Zeichencode-Bereich, ,in 9dem sich ,-./0123456789genau die Zeichen befinden , die wir benötigen

Als nächstes konvertieren wir alle nicht alphanumerischen Zeichen in Bindestriche (das ist jetzt nur und ,./-.

\W+
-

Dies wird nicht (nicht) übereinstimmen, _was in \w(Negation von \W) enthalten ist, weil es in der vorherigen Stufe entfernt wurde

JavaScript (ES6), 90 82 79 75 Byte

Dies ist ein Versuch, die Arbeit mit einem einzigen zu erledigen replace(). Dieser Code extrahiert nur die Zeichen, die uns interessieren, und ignoriert alles andere. Es gibt eine zusätzliche Logik, um die Bindestriche zu verarbeiten.

s=>(s.toLowerCase().replace(/[ a-z,-9]/g,c=>S=c<'0'?s+'-':s=s?S+c:c,s=0),s)

Testfälle

let f =

s=>(s.toLowerCase().replace(/[ a-z,-9]/g,c=>S=c<'0'?s+'-':s=s?S+c:c,s=0),s)

console.log(f(`Loading... Forever`));                         // -> loading-forever
console.log(f(`N(e(s(t))) a string`));                        // -> nest-a-string
console.log(f(`"Hello, World!"`));                            // -> hello-world
console.log(f(`URL-Friendly titles`));                        // -> url-friendly-titles
console.log(f(`C.U.S.R.S`));                                  // -> c-u-s-r-s
console.log(f(`1+2+3+4+...+n = -1/12?`));                     // -> 1234-n-1-12
console.log(f(`How can I use cmp(a,b)`));                     // -> how-can-i-use-cmpa-b
console.log(f(`Export The $PATH Variable, Line-By-Line`));    // -> export-the-path-variable-line-by-line
console.log(f(`Do n and n^3 have the same set of digits?`));  // -> do-n-and-n3-have-the-same-set-of-digits
console.log(f(`Quine Anagrams! (Cops' Thread)`));             // -> quine-anagrams-cops-thread
console.log(f(`The Golfer Adventure - Chapter 1`));           // -> the-golfer-adventure-chapter-1
console.log(f(`Bootloader golf: Brainf***`));                 // -> bootloader-golf-brainf
console.log(f(`0123`));                                       // -> 0123
console.log(f(`a a1`));                                       // -> a-a1
console.log(f(`2-1=1`));                                      // -> 2-11
console.log(f(',a^a,'));                                      // -> aa

V , 41, 40, 37 , 36 Bytes

VuÍ[ .,\/]/-
Í0-9a-z­]
Í-«/-
Í^-ü-$

Probieren Sie es online! oder Überprüfen Sie alle Testfälle auf einmal!

Wie üblich enthält dies eine Reihe von nicht druckbaren und Nicht-ASCII-Zeichen. Hier ist also ein Hexdump:

0000000: 5675 cd5b 202e 2c5c 2f5d 2f2d 0acd 8430  Vu.[ .,\/]/-...0
0000010: 2d39 612d 7aad 5d0a cd2d ab2f 2d0a cd5e  -9a-z.]..-./-..^
0000020: 2dfc 2d24                                -.-$

Es sind Herausforderungen wie diese, bei denen Vs "Compressed Regex" -System nützlich ist.

Erläuterung

Zuerst werden wir alles in Kleinbuchstaben umwandeln. Glücklicherweise gibt es eine sehr bequeme Möglichkeit, dies in zwei Bytes zu tun. Ich habe hier einen Tipp dazu geschrieben . So machen wir es

V           " Visually select this whole line
 u          " Convert this whole line to lowercase

Danach führen wir eine Reihe von komprimierten Ersatzbefehlen aus. Ein guter Überblick über die Funktionsweise von Vs komprimiertem regulären Ausdruck ist hier zu finden , aber die Grundidee ist, dass wir das High-Bit setzen können, um zu vermeiden, dass bestimmte Zeichen entkommen müssen. Eine weitere Annehmlichkeit besteht darin, dass Bereiche (wie :%) und Flags (wie /g) automatisch ausgefüllt werden. Letztendlich wird alles in vim-Ersatzbefehle übersetzt. Tatsächlich könnten wir sogar den Rest des Programms direkt in vim übersetzen. Das würde uns folgendes geben:

:%s/[ .,/]/-/g
:%s/[^0-9a-z\-]//g
:%s/-\+/-
:%s/^-\|-$//g

Wenn Sie vim-regex sprechen, sollte klarer sein, was der Rest des Programms jetzt tut. Also hier ist der Rest des Programms:

Í               " Substitute:
 [ .,\/]        "   a space, period, comma or forward slash. (Due to a strange bug, this needs to be escaped)
        /-      "   with a dash
Í               " Remove:
 [^0-9a-z­]     "   Any character that is not a dash or alpha-numeric
Í               " Substitute:
 -«             "   One or more dashes
   /-           "   with one dash
Í               " Remove:
 ^-             "   A dash at the beginning of a line
   ü            "   OR
    -$          "   a dash at the end of a line

JavaScript (ES6) 91 96

1 Byte gespeichert dank @ETHproductions

s=>s.toLowerCase().replace(/([ .,/-])|\W|_/g,(c,d)=>d?'-':'').replace(/^-*|-*$|-(?=-)/g,'')

Prüfung

F=
s=>s.toLowerCase().replace(/([ .,/-])|\W|_/g,(c,d)=>d?'-':'').replace(/^-*|-*$|-(?=-)/g,'')

;[['Loading... Forever.....', 'loading-forever'],
['N(e(s(t))) a string', 'nest-a-string'],
['"Hello, World!"', 'hello-world'],
['URL-Friendly titles', 'url-friendly-titles'],
['C.U.S.R.S','c-u-s-r-s'],
['1+2+3+4+...+n = -1/12?', '1234-n-1-12'],
['How can I use cmp(a,b)', 'how-can-i-use-cmpa-b'],
['Export The $PATH Variable, Line-By-Line', 'export-the-path-variable-line-by-line'],
['Do n and n^3 have the same set of digits?', 'do-n-and-n3-have-the-same-set-of-digits'],
['Quine Anagrams! (Cops\' Thread)', 'quine-anagrams-cops-thread'],
['The Golfer Adventure - Chapter 1', 'the-golfer-adventure-chapter-1'],
['Bootloader golf: Brainf***', 'bootloader-golf-brainf'],
['0123', '0123'],
['a a1', 'a-a1'],
['2-1=1', '2-11']]
.forEach(t=>{
  var i=t[0],k=t[1],r=F(i)
  console.log(r==k?'OK':'KO',i+' -> '+r,r==k?'':k)
})

Python 3, 103 100 96 95 Bytes

5 Bytes gespart dank Flp.Tkc

import re
lambda s,y=re.sub,d='-':y('-+',d,y('[^0-9a-z-]','',y('[ .,/]',d,s.lower()))).strip(d)

Retina, 34 Bytes

T`L`l
[^ az \ d., / -] +

\ W +
-
^ - | - $

Probieren Sie es online!

Beachten Sie den nachgestellten Zeilenumbruch. Im Wesentlichen die Umsetzung des OP.

MATL , 38 Bytes

'-'jyvk45y' .,/'m(t8Y245hm)'-*'45YX6L)

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

'-'jyv       % Take input line. Append and prepend a dash. Gives a char column vector
k            % Convert to lowercase
45y' .,/'m(  % Replace any of ' .,/' by a dash, using assignment indexing
t8Y245hm)    % Keep only alphanumeric chars or dashes, using reference indexing
'-*'45YX     % Replace each run of dashes by a single dash, using a regular expression
6L)          % Remove first and last chars, which are always dashes. Implicitly display

Ruby , 61 60 61 64 53 Bytes

(52 Byte Code plus ein Byte für die -p)

$_=$_.tr("A-Z ,-/","a-z ").gsub(/[^\w ]/){}.split*?-

Probieren Sie es online!

tr(… )- konvertiert Großbuchstaben, Leerzeichen, Kommas, Punkte und Schrägstriche. Ersetzen Sie das vorübergehend -durch Leerzeichen, damit ich es stripspäter verwenden kann.
Beachten Sie, dass das -Zeichen im "A-Z ,-/"Ausdruck tatsächlich ein Bereichsoperator ist, wodurch das .Zeichen ebenfalls einer Transformation unterzogen wird. Dieses Manöver wird eigentlich keine Bytes abschneiden, aber es ist schick, damit es bleiben kann.

gsub(/[^\w ]/){} - Alle Zeichen entfernen, die nicht im zulässigen Satz enthalten sind.

split- Technisch gesehen brauchen wir dieses Array nicht genau, sondern spliteliminieren führende und nachfolgende Whitespaces (die eigentlich -getarnte Zeichen sind). Als Bonus drückt dies Läufe von mehreren Räumen zusammen.

*?-- Abkürzung für .join("-"); Dies kehrt gleichzeitig die vorhergehende splitOperation und die Whitespace-Transformation um. Ein weiteres Byte wird gespeichert, indem die abgekürzte Notation für Zeichenliterale verwendet wird , sodass für das Programm Ruby 1.9 oder höher erforderlich ist.

Update 1: Verwenden Sie getsanstelle von Rubys Stream-Bearbeitungsmodus, um ein Byte zu sparen.
Rückgängig gemacht als je ValueInk Vorschlag .

Update 2: (+3 Bytes insgesamt)

• Feste Groß- und Kleinschreibung ..--hi, $/(→ hi) (+10 Byte) - erneut mit freundlicher Genehmigung des Benutzers ValueInk
• Malus für -p (+1 Byte)
• Wurde entfernt squeezeund gsubstattdessen verwendet (+2 Bytes) , was mir Folgendes ermöglichte:
• Verwenden Sie stripdiese Option , um die führenden und nachfolgenden Bindestriche (-10 Byte) zu behandeln .

Update 3: Hattrick von ValueInk. Wir sparen 11 Bytes, indem wir die String#splitAngewohnheit nutzen , Läufe desselben Trennzeichens automatisch zu quetschen, wodurch wir das gesamte Finale strip/ die gesamte gsubKette loswerden und durch ein split/ ersetzen können join. (-11 Bytes)

JavaScript (ES6), 74 bis 69 Byte

f=
s=>s.toLowerCase().replace(/[^-/,. a-z\d]/g,``).match(/\w+/g).join`-`

<input oninput=o.textContent=/[a-z\d]/i.test(this.value)?f(this.value):``><pre id=o>

Bearbeiten: 5 Bytes gespart, indem erkannt wurde, dass ich bereits alle Zeichen gelöscht habe, außer -/,. 0-9a-zdass ich \wdie verbleibenden Wörter damit abgleichen kann .

PHP, 87 Bytes

Die Idee der regulären Ausdrücke stammt aus vorhandenen Antworten.

<?=trim(preg_replace(['@[^ a-z,-9]@','@[ ,-/]+@'],['','-'],strtolower($_GET[T])),'-');

Es erfordert einen Server mit PHP und Zugriff über HTTP.

Der Titel muss auf der Taste sein T, und das Ergebnis wird auf dem Bildschirm gedruckt.

Beispiel: http://localhost/title.php?T=<my shiny title>

Bash / Unix-Tools, 56 Bytes

tr A-Z\ .,/ a-z-|tr -cds a-z0-9- -|sed s/^-//|sed s/-$//

Ersetzen Sie Großbuchstaben durch Kleinbuchstaben und die erforderlichen Sonderzeichen durch Bindestriche.

Löschen Sie andere Zeichen als Buchstaben, Ziffern und Bindestriche (Option -d) und drücken Sie dann die Option -s, um mehrere Bindestriche in einer Reihe zu einem Bindestrich zusammenzufassen.

Löschen Sie Bindestriche am Anfang und dann am Ende.

Powershell, 85 Bytes

($args[0].ToLower()-replace'[ .,/]','-'-replace'[^a-z,-9]'-replace'-+','-').Trim('-')

mach es klein, dann werden 3 reguläre Ausdrücke hintereinander ersetzt und alle nachfolgenden -abgeschnitten

JavaScript, 90 98 94 93 91 90 91 Bytes

1 Byte gespart dank @ edc65!

Dank @IsmaelMiguel für das Erkennen eines führenden Semikolons 1 Byte gespart!

1 Byte gewonnen nach einem Fehler für ,a-^-a,

f=s=>s.toLowerCase().replace(/[^ a-z,-9]/g,"").replace(/[ ,-/]+/g,"-").replace(/^-|-$/g,"")

Was mir an diesem Beitrag am besten gefällt, sind die Bereiche. In dem ersten replace, entfernen wir alles , was nicht alphanumerische und keine ist ,, -, ., /und kein Raum. Wir verwenden a-zzur Erkennung der Buchstaben und ,-9zur Erkennung dieser Sonderzeichen und -zahlen, da die Zeichencodes dieser ASCII-Literale alle in einer Reihe stehen!

, = 44
- = 45
. = 46
/ = 47
0 = 48
...
9 = 57

f=s=>s.toLowerCase().replace(/[^ a-z,-9]/g,"").replace(/[ ,-/]+/g,"-").replace(/^-|-$/g,"")

console.log(f("---"));//TEST
console.log(f("!@#$%ˆ&*()_+"));//TEST

console.log(f("Stewie's sequence: + * - / + * - /-"));

console.log(f("Loading... Forever"));
console.log(f("N(e(s(t))) a string"));
console.log(f("\"Hello, World!\""));
console.log(f("URL-Friendly titles"));

console.log(f("C.U.S.R.S"));
console.log(f("1+2+3+4+...+n = -1/12?"));
console.log(f("How can I use cmp(a,b)"));

console.log(f("Export The $PATH Variable, Line-By-Line"));
console.log(f("Do n and n^3 have the same set of digits?"));
console.log(f("Quine Anagrams! (Cops' Thread)"));
console.log(f("The Golfer Adventure - Chapter 1"));
console.log(f("Bootloader golf: Brainf***--"));

console.log(f("0123"));
console.log(f("a a1"));
console.log(f("2-1=1"));

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

Lua, 91 Bytes

a=a:lower():gsub( '[ .,/]', '-' ):gsub( '[^%w-]', '' ):gsub( '%-+', '-' ):match'%-?(.*)%-?'

Wo aist die URL-Zeichenfolge?

Erläuterung:

• Das meiste ist ziemlich einfach. a:lower()Gibt die Kleinbuchstabenfunktion zurück
• :gsub Findet die Übereinstimmung des Musters und ersetzt es durch die Zeichenfolge.
• '[ .,/]': Klammern bedeuten "oder", daher entspricht dies Leerzeichen, Punkt, Komma und Schrägstrich. Du musst nicht gierig sein, weil :gsubes alle Vorkommen gibt.
• '[^%w-]': ^bedeutet "nicht" in Klammern, %wbedeutet irgendetwas Alphanumerisches. Entspricht also '[^%w-]allem, was nicht alphanumerisch oder mit einem Bindestrich versehen ist.
• '%-+': Kombiniere so viele Striche wie möglich und ersetze sie mit nur einem Strich.
• match'%-?(.*)%-?': Wenn in Lua ein String das einzige Argument der Funktion ist, sind keine Klammern erforderlich. Es muss nur am Anfang und am Ende nach einem Bindestrich gesucht werden, da Bindestriche bereits minimiert wurden. Keine Notwendigkeit für Ankerzeichen, da .*alles passt, gierig.

C 194 Bytes

i,j;f(char*s,char*d){if(*s>47&*s<58|*s>96&*s<123)d[i++]=*s;if(*s>64&*s<91)d[i++]=*s+32;if(i-j&&*s>43&*s<48|*s==32&&*(s+1)&&*(s+1)>47|(*(s+1)<44&&*(s+1)^32)){d[i++]=45;j=i;}*++s?f(s,d):(d[i]=0);}

Rufen Sie an mit:

int main()
{
    char *in="Loading... Forever";
    char out[128];
    f(in,out);
    puts(out);
}

SAS, 108

Eine der weniger konkurrenzfähigen Antworten hier aufgrund der ausführlichen SAS-Syntax - die 9-Zeichen-Strafe pro Regex schmerzt wirklich -, aber es war eine gute Regex-Lernübung:

t=prxchange('s/^-|-$//',-1,prxchange('s/-+/-/',-1,compress(translate(lowcase(t),'----',' .,/'),'-','adk')));

Pyth, 35 Bytes

:r::rQ0"[-.,/]"d"[^\w ]"k6"[ -]+"\-

Erläuterung

    rQ0                              Convert letters to lower case
   :   "[-.,/]"d                     Replace all -.,/ with spaces
  :             "[^\w ]"k            Remove all remaining symbols
 r                       6           Remove leading and trailing spaces
:                         "[ -]+"\-  Turn runs of spaces and dashes to one dash

Perl 6, 75

{lc .subst(/<[\ .,/]>/,"-"):g.subst(/<[\W]-[\-]>/,""):g.subst(/\-+/,"-"):g}

GNU Sed, 65 Bytes

s/.*/\L\0/
s@[ .,/]@-@g
s/[^-a-z0-9]//g
s/-\+/-/g
s/^-\|-$//g

Eine Reihe von Regex-Substitutionen. Verwendet nicht-portable \Lvon GNU sed, um die Eingabe in Kleinbuchstaben zu schreiben. Führen Sie aus einer Datei mit sed -f.