Diese Frage wird einen Mechaniker aus dem Spiel "Path Of Exile" enthalten. In diesem Spiel gibt es Dinge, die als MAPS bezeichnet werden. Sie sind Gegenstände, mit denen Sie hochrangige Bereiche öffnen können. Sie können auch 3 davon kombinieren, um einen aktualisierten zu erhalten die Aufgabe dieser Herausforderung. Die Upgrade-Kombinationen lauten wie folgt:

A Crypt Map 68 -> Sewer Map
E Dungeon Map 68 -> Channel Map
I Grotto Map 68 -> Thicket Map
O Dunes Map 68 -> Mountain Ledge Map
U Pit Map 68 -> Cemetery Map
T Tropical Island Map 68 -> Arcade Map
N Desert Map 68 -> Wharf Map
S Sewer Map 69 -> Ghetto Map
H Channel Map 69 -> Spider Lair Map
R Thicket Map 69 -> Vaal Pyramid Map
D Mountain Ledge Map 69 -> Reef Map
L Cemetery Map 69 -> Quarry Map
C Arcade Map 69 -> Mud Geyser Map
M Wharf Map 69 -> Museum Map
W Ghetto Map 70 -> Arena Map
F Spider Lair Map 70 -> Overgrown Shrine Map
G Vaal Pyramid Map 70 -> Tunnel Map 
Y Reef Map 70 -> Shore Map
P Quarry Map 70 -> Spider Forest Map
B Mud Geyser Map 70 -> Promenade Map
V Museum Map 70 -> Arena Map
K Arena Map 71 -> Underground Sea Map 
J Overgrown Shrine Map 71 -> Pier Map
X Tunnel Map 71 -> Bog Map
Q Shore Map 71 -> Graveyard Map
Z Spider Forest Map 71 -> Coves Map
Ó Promenade Map 71 -> Villa Map 
É Underground Sea Map 72 -> Temple Map
Á Pier Map 72 -> Arachnid Nest Map
Í Bog Map 72 -> Strand Map
Ú Graveyard Map 72 -> Dry Woods Map
Ü Coves Map 72 -> Colonnade Map
Ö Villa Map 72 -> Catacomb Map
Ä Temple Map 73 -> Torture Chamber Map
Ë Arachnid Nest Map 73 -> Waste Pool Map
Ï Strand Map 73 -> Mine Map
Æ Dry Woods Map 73 -> Jungle Valley Map
ΠColonnade Map 73 -> Labyrinth Map
Ñ Catacomb Map 73 -> Torture Chamber Map
Ÿ Torture Chamber Map 74 -> Cells Map
1 Waste Pool Map 74 -> Canyon Map
2 Mine Map 74 -> Dark Forest
3 Jungle Valley Map 74 -> Dry Peninsula Map
4 Labyrinth Map 74 -> Orchard Map
5 Cells Map 75 -> Underground River Map
6 Canyon Map 75 -> Arid Lake Map
7 Dark Forest Map 75 -> Gorge Map
8 Dry Peninsula Map 75 -> Residence Map
9 Orchard Map 75 -> Underground River Map
0 Underground River Map 76 -> Necropolis Map
? Arid Lake Map 76 -> Plateau Map
! Gorge Map 76 -> Bazaar Map
( Residence Map 76 -> Volcano Map
) Necropolis Map 77 -> Crematorium Map
- Plateau Map 77 -> Precinct Map
/ Bazaar Map 77 -> Academy Map
\ Volcano Map 77 -> Springs Map
| Crematorium Map 78 -> Shipyard Map
= Precinct Map 78 -> Overgrown Ruin Map
* Academy Map 78 -> Village Ruin Map
† Springs Map 78 -> Arsenal Map
‡ Shipyard Map 79 -> Wasteland Map
§ Overgrown Ruin Map 79 -> Courtyard Map
[ Village Ruin Map 79 -> Excavation Map
] Arsenal Map 79 -> Waterways Map
_ Wasteland Map 80 -> Palace Map
~ Courtyard Map 80 -> Shrine Map
{ Excavation Map 80 -> Maze Map
} Waterways Map 80 -> Palace Map
© Palace Map 81 -> Abyss Map
€ Shrine Map 81 -> Abyss Map
< Maze Map 81 -> Colosseum Map 
> Vaal Temple Map 81 -> Colosseum Map
µ Abyss Map 82
» Colosseum Map 82

Diese Linien folgen diesem Schema:

Symbol of the map | Name of the map | Level of the map | Map received from combining

Beachten Sie, dass die Abgrund- und Kolosseumkarte nicht zu höheren Ebenen kombiniert werden, da sie die höchste Ebene sind.

EINGABE:
Ihre Eingabe ist eine Folge von Symbolen, die den Kartensymbolen entsprechen, z. B. AAAEE, was 3 x Krypta-Karte und 2 x Dungeon-Karte bedeuten würde.

AUSGABE:
Die Ausgabe ist wieder eine Zeichenfolge, die die höchstmögliche Kombination der Eingabekarten darstellt. Jede Kombination von Ausgaben ist zulässig, solange jede Karte vorhanden ist.

BEISPIELE:

INPUT: A
OUTPUT: A

INPUT: AAA
OUTPUT: S

INPUT: AAAEEEIII
OUTPUT: SHR or HRS or RHS or SRH 

INPUT: AAAAAAAAAE
OUTPUT: WE or EW

INPUT: »»»»»
OUTPUT: »»»»»

Wertung:
Ihre Punktzahl wird anhand dieser Formel berechnet, die auch im Spiel zur Berechnung der Schadensreduzierung verwendet wird:

POINTS = 1000 - (ByteCount / (ByteCount + 1000) * 1000);

BONUSPUNKTE:

1. Wenn Sie sowohl der Eingabe als auch der Ausgabe eine Runlenght-Codierung hinzufügen, multiplizieren Sie Ihre Punkte mit 1,2, Beispiel 3A-Eingabe anstelle von AAA. Sie können die Standardeingabe weglassen, wenn Ihre Antwort dies unterstützt.

2. Wenn Ihr Programm die tatsächlichen Kartennamen als Eingabe / Ausgabe zulässt und dann Ihre Punkte mit 1,5 multipliziert, können Sie den Teil "Karte" des Kartennamens weglassen, sodass als Beispiel die Eingabe " Krypta Krypta Krypta " und die Ausgabe " Kanalisation " in Ordnung ist. Ihr Skript muss auch die Standardeingabe nicht mehr verstehen, wenn Sie diese Methode verwenden. Diese Methode erfordert auch ein Leerzeichen zwischen den Namen in der Eingabe und Ausgabe.

3. Wenn Ihre Ausgabezeichenfolge von der Karte der niedrigsten zur höchsten Ebene wechselt, multiplizieren Sie Ihre Punkte mit 1,08. Karten mit derselben Ebene müssen nicht auf eine bestimmte Weise sortiert werden.

Sie können alle 3 Bonuspunkte kombinieren.

ANTWORT MIT DEN MEISTEN PUNKTEN GEWINNT!

Haskell, 306 Bytes, Punkte = 766 * 1,2 * 1,08 = 992,343

import Control.Arrow;main=print=<<(\x->unwords.map(\(x,y)->show x++[y]).filter((>0).fst).g=<<(read***head)<$>(lex=<<words x))<$>getLine;g z@(x,y)|x<3=[z]|1<2=maybe[z](\w->(x`mod`3,y):g(x`div`3,w)).lookup y$words"ASWKÉÄŸ50)|‡_©µ EHFJÁË16?-=§~€µ IRGXÍÏ27!/*[{<» ULPZÜŒ490 TCBÓÖÑŸ NMVK >»">>= \x->zip x$tail x

Ich könnte noch ein paar Bytes herausdrücken, sollte mich jemand schlagen, aber jetzt werde ich es so lassen, wie es ist.

Haskell, 284 Bytes, Punkte = 779 * 1,2 * 1,08 = 1009,346

import Control.Arrow;main=interact$show.(\x->unwords[show a++[b]|(a,b)<-g=<<second head<$>(reads=<<words x),a>0]);g z@(x,y)|x<3=[z]|1<2=maybe[z](\w->(x`mod`3,y):g(x`div`3,w)).lookup y$words"ASWKÉÄŸ50)|‡_©µ EHFJÁË16?-=§~€µ IRGXÍÏ27!/*[{<» ULPZÜŒ490 TCBÓÖÑŸ NMVK >»">>=(flip zip=<<tail)

Ich habe trotzdem ein paar Bytes mehr herausgepresst.

Haskell, 248 Bytes, Punkte = 801 * 1,2 * 1,08 = 1038,462

main=interact$ \x->unwords[show a++b|(a,b)<-(reads=<<words x)>>=g,a>0];g z@(x,y)|x<3=[z]|1<2=maybe[z](\w->(x`mod`3,y):g(x`div`3,w))$pure<$>lookup(head y)(zip<*>tail=<<words"ASWKÉÄŸ50)|‡_©µ EHFJÁË16?-=§~€µ IRGXÍÏ27!/*[{<» ULPZÜŒ490 TCBÓÖÑŸ NMVK >»")

Ich werde auch ein paar Tische hinterlassen, die ich für andere gemacht habe:

68   AS EH IR OD UL TC NM
69   SW HF RG DY LP CB MV
70   WK FJ GX YQ PZ BÓ VK
71   KÉ JÁ XÍ QÚ ZÜ ÓÖ
72   ÉÄ ÁË ÍÏ ÚÆ ÜŒ ÖÑ
73   ÄŸ Ë1 Ï2 Æ3 Œ4 ÑŸ
74   Ÿ5 16 27 38 49
75   50 6? 7! 8( 90
76   0) ?- !/ (\
77   )| -= /* \†
78   |‡ =§ *[ †]
79   ‡_ §~ [{ ]}
80   _© ~€ {< }©
81   ©µ €µ <»
82   µ  µ  »

     >»

Sie lesen es von oben nach unten, zwei Buchstaben gleichzeitig (oder ignorieren ungerade Spalten). Drei A machen ein S, drei S machen ein W und so weiter. Ketten, die enden, werden einfach in die erste Spalte der nächsten Zeile umgebrochen. Keine drei Karten machen ein>.

Hier sind die Ketten von Karten, die Sie ohne Wiederholungen erstellen können:

ASWKÉÄŸ50)|‡_©µ
EHFJÁË16?-=§~€µ
IRGXÍÏ27!/*[{<»
ULPZ܌490
TCBÓÖÑŸ
NMVK
>»

C #, 364 361 Bytes, Punkte = 734,754 x 1,08 = 793,534

Könnte auch den Ball mit einem großen ins Rollen bringen ...

string F(string s){var m=@"AEIOUTNSHRDLCMWFGYPBVKJXQZÓÉÁÍÚÜÖÄËÏƌџ1234567890?!()-/\|=*†‡§[]_~{}©€<>µ»";var g=new int[75];foreach(int a in s.Select(c=>m.IndexOf(c)))g[a]++;int i=0;for(;i<73;){g[m.IndexOf(@"SHRDLCMWFGYPBVKJXQZÓKÉÁÍÚÜÖÄËÏƌџ1234Ÿ567890?!(0)-/\|=*†‡§[]_~{}©€<©µµ»»"[i])]+=g[i]/3;g[i++]%=3;}return string.Join("",g.Zip(m,(x,l)=>"".PadLeft(x,l)));}

Ich habe noch keine clevere Möglichkeit gefunden, die scheinbar zufällig codierten Zeichen ihrem relativen Wert zuzuordnen, daher habe ich vorerst eine Brute-Force-Methode angewendet.

Dies implementiert Bonus-Feature 3 aufgrund der Gruppierungsmethode, die mir coole 58ish-Punkte einbringt.

Bearbeiten: Die Ausgabeschleife wurde in join / zip umgeschrieben

SWI-Prolog, 354 Bytes, Punkte = 738,552 * 1,08 = 797,64

a(A,Z):-msort(A,S),b(S,[],B),(msort(B,S),string_codes(Z,S);a(B,Z)).
b(X,R,Z):-(X=[A,A,A|T],nth0(I,`AEIOUTNSHRDLCMWFGYPBVKJXQZÓÉÁÍÚÜÖÄËÏƌџ1234567890?!()-/\\|=*†‡§[]_~{}©€<>`,A),nth0(I,`SHRDLCMWFGYPBVKJXQZÓKÉÁÍÚÜÖÄËÏƌџ1234Ÿ567890?!(0)-/\\|=*†‡§[]_~{}©€<©µµ»»`,B),b(T,[B|R],Z);X=[A|T],b(T,[A|R],Z);Z=R).

Erwartet Eingaben als Code-Strings, die beispielsweise a(`AAAEEEIII`,Z).ausgegeben werden Z = "SRH".

Ich werde sehen, was ich gegen die beiden anderen Boni tun kann ...

Javascript, 432 Bytes, Punkte = 698,32 * 1,08 * 1,2 = 905,02

function g(r){for(var n="AEIOUTNSHRDLCMWFGYPBVKJXQZÓÉÁÍÚÜÖÄËÏƌџ1234567890?!()-/|=*†‡§[]_~{}©€<>",t="SHRDLCMWFGYPBVKJXQZÓKÉÁÍÚÜÖÄËÏƌџ1234Ÿ567890?!(0)-/|=*†‡§[]_~{}©€<©µµ»»",a=/([^»µ])\1{2}/,c=/\d+/,e=/\d+(.)/,f=0;0!==(f=r.match(c)-0);)r=r.replace(c,Array(f).join(r.match(e)[1]));for(;null!==(f=r.match(a));)r=r.replace(a,t.charAt(n.search(f[1])));return r.split("").sort(function(r,t){return n.indexOf(r)-n.indexOf(t)}).join("")}

ECMAScript 6, 417 Bytes, Punkte = 705,72 * 1,08 * 1,2 = 914,61

Keine Online-Minifier-Version: (Die letzte Version wurde durch einen Minifier übergeben. )

let F=s=>{for(var m="AEIOUTNSHRDLCMWFGYPBVKJXQZÓÉÁÍÚÜÖÄËÏƌџ1234567890?!()-/\|=*†‡§[]_~{}©€<>",r="SHRDLCMWFGYPBVKJXQZÓKÉÁÍÚÜÖÄËÏƌџ1234Ÿ567890?!(0)-/\|=*†‡§[]_~{}©€<©µµ»»",x=/([^»µ])\1{2}/,y=/\d+/,z=/\d+(.)/,p=0;(p=s.match(y)-0)!==0;)s=s.replace(y,Array(p).join(s.match(z)[1]));for(;(p=s.match(x))!==null;)s=s.replace(x,r.charAt(m.search(p[1])));return s.split('').sort((a,b)=>m.indexOf(a)-m.indexOf(b)).join('');};

Lauf mit Babel

Getestet mit folgenden Eingaben:

1. AAA
2. AAAEEEIII
3. 3A3E3I
4. »»»»»
5. 5»

Allgemeine Lösung

Grundsätzlich wird Regex verwendet, wann immer dies möglich ist

var m = "AEIOUTNSHRDLCMWFGYPBVKJXQZÓÉÁÍÚÜÖÄËÏƌџ1234567890?!()-/\|=*†‡§[]_~{}©€<>";
var r = "SHRDLCMWFGYPBVKJXQZÓKÉÁÍÚÜÖÄËÏƌџ1234Ÿ567890?!(0)-/\|=*†‡§[]_~{}©€<©µµ»»";
var x = /([^»µ])\1{2}/;

while((p=s.match(x))!==null){
    s=s.replace(x,r.charAt(m.search(p[1])));
}

Hier ist nichts Besonderes, nur ein Match für die jeweilige Ausgabe zu ersetzen.

Für den 1.2 Bonus

Wenn Sie die Zahlen und den folgenden Buchstaben neu ausdrücken, sieht der lesbare Code folgendermaßen aus:

// variable 's' is the input string

var y = /\d+/;
var z = /\d+(.)/;

var p = 0;

while((p=s.match(y)-0) !== 0) {
    s=s.replace(y,Array(p).join(s.match(z)[1]));
}

Wie Sie sehen können, s.match(y) - 0wird die übereinstimmende Zeichenfolge von 0 subtrahiert, um eine Analyse zu erzwingen, ohne tatsächlich aufzurufen parseInt().

Außerdem wird im Array(p).join(s.match(z)[1])Grunde genommen eine Reihe p leerer Elemente mit dem im Match gefundenen Zeichen verbunden. Dies ist eine einfache Möglichkeit, einen Buchstaben (sagen wir mal E) so poft zu drucken .

Für den 1.08 Bonus

Sortieralgorithmus:

s.split('').sort(function(a,b) {
    return m.indexOf(a) - m.indexOf(b);
}).join('');

Javascript (ES6), 389 Bytes, Punkte = 719,942 * 1,08 * 1,2 = 933,045

Zumindest vorerst an der Spitze ...

a=>{a=a.replace(/(\d)(.)/g,(m,A,B)=>B.repeat(A)),x='AEIOUTNSHRDLCMWFGYPBVKJXQZÓÉÁÍÚÜÖÄËÏƌџ1234567890?!()-/\\|=*†‡§[]_~{}©€<>',y='SHRDLCMWFGYPBVKJXQZÓKÉÁÍÚÜÖÄËÏƌџ1234Ÿ567890?!(0)-/\\|=*†‡§[]_~{}©€<©µµ»»',s=_=>(a=[...a].sort((a,b)=>x[I='indexOf'](a)-x[I](b)).join``);s();for(i=0;i<x.length;i++){a=a.replace(new RegExp(`[${('\\|'[I](h=x[i])<0?'':'\\')+h}]{3}`,'g'),y[i]);s()}return a}

Probieren Sie es hier aus:

F=a=>{a=a.replace(/(\d)(.)/g,(m,A,B)=>B.repeat(A)),x='AEIOUTNSHRDLCMWFGYPBVKJXQZÓÉÁÍÚÜÖÄËÏƌџ1234567890?!()-/\\|=*†‡§[]_~{}©€<>',y='SHRDLCMWFGYPBVKJXQZÓKÉÁÍÚÜÖÄËÏƌџ1234Ÿ567890?!(0)-/\\|=*†‡§[]_~{}©€<©µµ»»',s=_=>(a=[...a].sort((a,b)=>x[I='indexOf'](a)-x[I](b)).join``);s();for(i=0;i<x.length;i++){a=a.replace(new RegExp(`[${('\\|'[I](h=x[i])<0?'':'\\')+h}]{3}`,'g'),y[i]);s()}return a};

input=document.getElementById("input");
p=document.getElementById("a");
input.addEventListener("keydown", function(){
  setTimeout(function(){p.innerHTML = F(input.value);},10);
})

<form>Type your text here: <input type="text" id="input" value="3A"/></form>

<h3>Output:</h3>
<p id="a">S</p>

Der 1.2 Bonus ist in seiner Formatierung etwas knifflig. Wenn Sie eine reguläre Nummer eingeben möchten, setzen Sie eine 1davor.

Grundsätzlich durchsucht dies jeden Charakter, der ein Upgrade hat (alle außer µund »), findet dann alle Dreiergruppen dieses Charakters und ersetzt sie durch das aktualisierte Zeichen. Das Sortieren nach jedem .replacewar der beste Weg, um sicherzustellen, dass dies immer richtig funktioniert. Das war also ein automatischer Bonus. Der 1.2 Bonus war etwas schwieriger, aber ich habe ihn in 45 Bytes aussortiert. Der 1,5-Bonus ist es einfach überhaupt nicht wert, da er eine Tonne mehr Codierung erfordert und mindestens die Länge verdoppeln würde.

Vorschläge sind wie immer sehr willkommen!