Caminho das combinações de mapas do exílio

10

Esta questão apresentará um mecânico do jogo "Path Of Exile". Neste jogo, existem coisas chamadas MAPS , itens que você pode usar para abrir áreas de alto nível. Você também pode combinar 3 delas para obter uma versão atualizada. a tarefa deste desafio. As combinações de atualização são as seguintes:

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 linhas seguem este sheme:

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

Observe que o mapa do abismo e do coliseu não se combina com os de nível superior, pois são o nível mais alto.

ENTRADA:
Sua entrada será uma sequência de símbolos que correspondem aos símbolos do mapa, por exemplo, AAAEE, o que significaria 3 x mapa de criptografia e 2 x mapa de masmorra.

SAÍDA:
A saída será novamente uma sequência de símbolos que representaria a combinação mais alta possível dos mapas de entrada. Qualquer combinação de saída é permitida, desde que contenha todos os mapas.

EXEMPLOS: 

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

PONTUAÇÃO:
Sua pontuação será calculada através desta fórmula, que também é usada no jogo para calcular a redução de dano:

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

PONTOS BÔNUS:

  1. Se você adicionar a codificação de runlenght à entrada e à saída, multiplique seus pontos por 1,2, exemplo 3A de entrada em vez de AAA. Você pode omitir a entrada padrão se sua resposta suportar isso.

  2. Se o seu programa permitir os nomes reais do mapa como entrada / saída e multiplicar seus pontos por 1,5, você poderá omitir a parte "map" do nome do mapa, de modo que um exemplo de entrada " crypt crypt crypt " e saída " esgoto " estejam ok. Seu script também não precisa mais entender a entrada padrão se você usar esse método. Este método também requer um espaço entre os nomes na entrada e na saída.

  3. Se sua sequência de saída for do mapa de nível mais baixo para o mais alto, multiplique seus pontos por 1,08, os mapas com o mesmo nível não precisam ser classificados de nenhuma maneira específica.

Você pode combinar todos os 3 pontos de bônus.

RESPOSTA COM MAIS PONTOS GANHA!

code-challenge Vajura
fonte
Podemos assumir que, na entrada, o mesmo tipo de mapa estará próximo um do outro? Por exemplo, no caso de teste 3, não precisamos lidar com algo como AEIAEIAEI?
Sok
Sem a entrada será sempre aleatória, vou bumb-se os pontos de bônus para essa parte, agora que penso nisso
Vajura
11
Encontre o seu próprio caminho para o interior, exílio! : ^ P
FryAmTheEggman
Se a entrada for aleatória, como funciona o bônus de duração? Podemos obter entradas como 2AEApara AAEA? Ou será 3AE?
Fatalize 13/08/15
Huh, eu não entendo.
precisa saber é o seguinte

Respostas:

5

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

Eu poderia extrair mais alguns bytes se alguém me vencesse, mas por enquanto vou deixar como está.

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

Eu espremi mais alguns bytes, independentemente.

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

Também vou deixar algumas tabelas que fiz para outras pessoas usarem:

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

     >»

Você lê de cima para baixo, duas letras de cada vez (ou ignora colunas ímpares). Três A fazem um S, Três S-es fazem um W e assim por diante. Cadeias que terminam simplesmente envolvem a primeira coluna na próxima linha. Três mapas não fazem um>.

Aqui estão as cadeias de mapas que você pode fazer sem repetições: 

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

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

Pode muito bem fazer a bola rolar com uma 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)));}

Ainda tenho que pensar em uma maneira inteligente de mapear os caracteres codificados aparentemente aleatórios para seu valor relativo, então usei um método de força bruta por enquanto.

Isso implementa o recurso de bônus 3 em virtude do método de agrupamento, o que me confere alguns pontos interessantes.

Editar: reescrever o loop de saída em join / zip

Sok
fonte
2

SWI-Prolog, 354 bytes, pontos = 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 sequências de códigos, por exemplo a(`AAAEEEIII`,Z)., saída Z = "SRH".

Vou ver o que posso fazer sobre os outros dois bônus ...

Fatalizar
fonte
2

Javascript, 432 bytes, pontos = 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, pontos = 705,72 * 1,08 * 1,2 = 914,61

Nenhuma versão on-line do minificador: (a última versão foi passada através de um 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('');};

Corra com Babel

Testado com as seguintes entradas:

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

Solução geral

Basicamente usando regex sempre que possível

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 extravagante aqui, apenas substituindo uma correspondência para a respectiva saída.

Para o bônus 1.2

Regexando os números e a seguinte letra, o código legível é assim:

// 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 você pode ver, s.match(y) - 0a string correspondente é subtraída por 0, para forçar uma análise int sem realmente chamar parseInt().

Também Array(p).join(s.match(z)[1])une basicamente uma matriz de elementos p vazios , com o caractere encontrado na partida, que é uma maneira fácil de imprimir uma letra (digamos E) pvárias vezes.

Para o bônus 1.08

Algoritmo de classificação:

s.split('').sort(function(a,b) {
    return m.indexOf(a) - m.indexOf(b);
}).join('');
Christopher Francisco
fonte
Não vejo como é possível obter uma pontuação básica de 999.999 com 432 bytes. Recebo 698.324 com a fórmula fornecida.
Fatalize 13/08/2015
My bad, I deve ter digitado a fórmula errada, eu vou consertá-lo
Christopher Francisco
2

Javascript (ES6), 389 bytes, pontos = 719,942 * 1,08 * 1,2 = 933,045

Na liderança, pelo menos por enquanto ...

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}

Experimente aqui:

Mostrar snippet de código

O bônus 1.2 é um pouco complicado em sua formatação. Se você deseja inserir um número regular, coloque um 1antes dele.

Basicamente, este scans através de cada personagem que tem um upgrade (todos exceto µe »), em seguida, encontra todos os conjuntos de três deste personagem e substitui-los com o caractere atualizado. Classificar depois de cada um .replaceera a melhor maneira de garantir que isso sempre funcionasse corretamente, de modo que era um bônus automático. O bônus 1.2 foi um pouco mais difícil, mas eu o resolvi em 45 bytes. O bônus de 1,5 simplesmente não vale a pena, pois exige uma tonelada a mais de codificação e pelo menos dobraria o comprimento.

Como sempre, sugestões são muito bem-vindas!

ETHproductions
fonte