Esta pregunta contará con una mecánica del juego "Path Of Exile". En este juego hay cosas llamadas MAPAS , son elementos que puedes usar para abrir áreas de alto nivel, también puedes combinar 3 de ellos para obtener uno mejorado que será La tarea de este desafío. Las combinaciones de actualización son las siguientes:

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

Estas líneas siguen este esquema:

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

Tenga en cuenta que el mapa del abismo y el coliseo no se combinan en los de nivel superior, ya que son el nivel más alto.

ENTRADA:
su entrada será una cadena de símbolos que corresponden a los símbolos del mapa, por ejemplo, AAAEE que significaría 3 x mapa de criptas y 2 x mapa de mazmorras.

SALIDA:
La salida volverá a ser una cadena de símbolos que representaría la combinación más alta posible de los mapas de entrada. Se permite cualquier combinación de resultados siempre que presente todos los mapas.

EJEMPLOS

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: »»»»»

PUNTUACIÓN:
Tu puntuación se calculará a través de esta fórmula, que también se usa en el juego para calcular la reducción de daños:

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

PUNTOS EXTRA:

1. Si agrega codificación de longitud de ejecución tanto a la entrada como a la salida, multiplique sus puntos por 1.2, por ejemplo, entrada 3A en lugar de AAA. Puede omitir la entrada estándar si su respuesta lo respaldará.

2. Si su programa permitirá los nombres de mapas reales como entrada / salida y luego multiplique sus puntos por 1.5, puede omitir la parte "mapa" del nombre del mapa para que como entrada de ejemplo " cripta cripta cripta " y salida " alcantarilla " esté bien. Su script tampoco necesita entender la entrada estándar si usa este método. Este método también requiere un espacio entre los nombres tanto en la entrada como en la salida.

3. Si su cadena de salida va del mapa del nivel más bajo al más alto, entonces multiplique sus puntos por 1.08, los mapas con el mismo nivel no necesitan ser ordenados de ninguna manera en particular.

Puedes combinar los 3 puntos de bonificación.

¡RESPUESTA CON LA MAYORÍA DE GANANCIAS!

Haskell, 306 bytes, puntos = 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

Podría exprimir algunos bytes más si alguien me ganara, pero por ahora lo dejaré como está.

Haskell, 284 bytes, puntos = 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)

Exprimí algunos bytes más independientemente.

Haskell, 248 bytes, puntos = 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 >»")

También voy a dejar algunas tablas que hice para que otros las usen:

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   µ  µ  »

     >»

Lo lees de arriba abajo, dos letras a la vez (o ignoras columnas impares). Tres A hacen una S, Tres S-es hacen una W y así sucesivamente. Las cadenas que terminan simplemente se envuelven a la primera columna en la siguiente línea. No hay tres mapas hace un>.

Aquí están las cadenas de mapas que puede hacer sin repeticiones:

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

C#, 364 361 bytes, puntos = 734.754 x 1.08 = 793.534

También podría hacer que la pelota ruede con una grande ...

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

Todavía tengo que pensar en una forma inteligente de mapear los caracteres codificados aparentemente aleatorios a su valor relativo, por lo que he utilizado un método de fuerza bruta por ahora.

Esto implementa la función de bonificación 3 en virtud del método de agrupación, que me da unos 58 puntos geniales.

Editar: reescribió el bucle de salida en join / zip

SWI-Prolog, 354 bytes, puntos = 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).

Espera entradas como cadenas de códigos, por ejemplo, a(`AAAEEEIII`,Z).saldrá Z = "SRH".

Veré qué puedo hacer con los otros dos bonos ...

Javascript, 432 bytes, puntos = 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, puntos = 705.72 * 1.08 * 1.2 = 914.61

Sin versión de minificador en línea: (la última versión se pasó a través de un minificador )

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('');};

Corre con Babel

Probado con las siguientes entradas:

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

Solución general

Básicamente, utilizando expresiones regulares siempre que sea posible

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

Nada lujoso aquí, solo reemplaza una coincidencia para la salida respectiva.

Por el 1.2 Bono

Regexing los números y la siguiente letra, el código legible es así:

// 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]));
}

Como puede ver, s.match(y) - 0la cadena coincidente se resta por 0, es decir, forzar un análisis int sin llamar realmente parseInt().

También Array(p).join(s.match(z)[1])básicamente se une a una serie de elementos p vacíos , con el carácter encontrado en la coincidencia, esa es una manera fácil de imprimir una letra (digamos E) pcantidad de veces.

Por la bonificación 1.08

Algoritmo de clasificación:

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

Javascript (ES6), 389 bytes, puntos = 719.942 * 1.08 * 1.2 = 933.045

A la cabeza, al menos por ahora ...

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}

Pruébalo aquí:

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>

El bono 1.2 es algo complicado en su formato. Si desea ingresar un número regular, coloque un 1antes.

Básicamente, esto escanea a través de cada personaje que tiene una actualización (todos excepto µy »), luego encuentra todos los conjuntos de tres de este personaje y los reemplaza con el personaje mejorado. Ordenar después de cada uno .replaceera la mejor manera de asegurarse de que esto siempre funcionara correctamente, por lo que era un bono automático. El bono 1.2 fue un poco más difícil, pero lo resolví en 45 bytes. La bonificación de 1.5 simplemente no vale la pena, ya que requiere una tonelada más de codificación y al menos duplicaría la longitud.

¡Como siempre, las sugerencias son bienvenidas!