Percorso delle combinazioni di mappe dell'esilio


10

Questa domanda presenterà un meccanico del gioco "Path Of Exile" in questo gioco ci sono cose chiamate MAPS sono oggetti che puoi usare per aprire aree di alto livello, puoi anche combinarne 3 per ottenere uno aggiornato che sarà il compito di questa sfida. Le combinazioni di aggiornamento sono le seguenti:

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

Queste linee seguono questo sheme:

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

Si noti che l'abisso e la mappa del Colosseo non si combinano in quelli di livello superiore poiché sono il livello più alto.

INGRESSO: il
tuo input sarà una stringa di simboli che corrispondono ai simboli della mappa, ad esempio AAAEE che significherebbe 3 x mappa cripta e 2 x mappa sotterranea.

OUTPUT:
L'output sarà di nuovo una stringa di simboli che rappresenterebbe la combinazione più alta possibile delle mappe di input. È consentita qualsiasi combinazione di output purché presenti ogni mappa.

ESEMPI:

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

PUNTEGGIO: il
tuo punteggio verrà calcolato attraverso questa formula, che viene anche effettivamente utilizzata nel gioco per calcolare la riduzione del danno:

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

PUNTI BONUS:

  1. Se aggiungi la codifica runlenght sia all'input che all'output, moltiplica i tuoi punti per 1,2, ad esempio input 3A anziché AAA. Puoi omettere l'input standard se la tua risposta lo supporterà.

  2. Se il tuo programma consentirà i nomi effettivi della mappa come input / output, quindi moltiplica i tuoi punti per 1,5, puoi inserire la parte "map" del nome della mappa, ad esempio input " crypt crypt crypt " e l'output " fogna " è ok. Inoltre, lo script non deve più comprendere l'input standard se si utilizza questo metodo. Questo metodo richiede anche uno spazio tra i nomi sia in input che in output.

  3. Se la stringa di output passa dalla mappa di livello più basso a quella più alta, moltiplicare i punti per 1,08, le mappe con lo stesso livello non devono essere ordinate in alcun modo particolare.

Puoi combinare tutti e 3 i punti bonus.

RISPONDE CON LA MAGGIOR PARTE DEI PUNTI VINCE!


Possiamo supporre che, nell'input, lo stesso tipo di mappa sarà uno accanto all'altro? Ad esempio, nel caso di test 3 non abbiamo a che fare con qualcosa del genere AEIAEIAEI?
Ho

No, l'input sarà sempre casuale, accumulerò i punti bonus per quella parte ora che ci penso
Vajura,

1
Trova la tua strada nell'entroterra, esilio! : ^ P
FryAmTheEggman,

Se l'input è casuale, come funziona il bonus di lunghezza? Possiamo ottenere input come 2AEAper AAEA? O sarà 3AE?
Fatalizza il

Eh, non capisco ._.
OverCoder

Risposte:


5

Haskell, 306 byte, punti = 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

Potrei spremere qualche byte in più se qualcuno mi picchiasse, ma per ora lo lascerò così com'è.

Haskell, 284 byte, punti = 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)

Ho spremuto qualche byte in più a prescindere.

Haskell, 248 byte, punti = 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 >»")

Lascerò anche alcuni tavoli che ho creato per gli altri da usare:

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 leggi dall'alto verso il basso, due lettere alla volta (o ignora le colonne dispari). Tre A fanno una S, Tre S fanno una W e così via. Le catene che finiscono semplicemente si avvolgono nella prima colonna della riga successiva. Nessuna tre mappe crea un>.

Ecco le catene di mappe che puoi creare senza ripetizioni:

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

4

C #, 364 361 byte, punti = 734.754 x 1.08 = 793.534

Potrebbe anche far rotolare la palla 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)));}

Devo ancora pensare a un modo intelligente di mappare i caratteri codificati apparentemente casuali sul loro valore relativo, quindi per ora ho usato un metodo di forza bruta.

Questo implementa la funzione bonus 3 in virtù del metodo di raggruppamento, che mi fa guadagnare 58 punti fantastici.

Modifica: riscrivi il loop di output in join / zip


2

SWI-Prolog, 354 byte, punti = 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).

Si aspetta input come stringhe di codici, ad esempio a(`AAAEEEIII`,Z).verranno emessi Z = "SRH".

Vedrò cosa posso fare con gli altri due bonus ...


2

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

Nessuna versione del minificatore online: (l'ultima versione è stata passata attraverso un minificatore )

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

Corri con Babele


Testato con i seguenti input:

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

Soluzione generale

Fondamentalmente usando regex quando possibile

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

Niente di speciale qui, sostituendo solo una corrispondenza per il rispettivo output.

Per il bonus 1.2

Riguardando i numeri e la lettera seguente, il codice leggibile va così:

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

Come puoi vedere, s.match(y) - 0la stringa corrispondente viene sottratta da 0, ovvero forzare un'analisi int senza effettivamente chiamare parseInt().

Inoltre Array(p).join(s.match(z)[1])si unisce in pratica una serie di p vuoti elementi, con il carattere trovato nella partita, che è un modo semplice per stampare una lettera (diciamo E) pquantità di volte.

Per il bonus 1,08

Algoritmo di ordinamento:

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

Non vedo come possibilmente ottenere un punteggio di base di 999.999 con 432 byte. Ottengo 698.324 con la formula indicata.
Fatalizza il

Mio male, devo aver digitato la formula in modo errato, la aggiusterò
Christopher Francisco,

2

Javascript (ES6), 389 byte, punti = 719.942 * 1.08 * 1.2 = 933.045

In testa, almeno per ora ...

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}

Provalo qui:

Il bonus 1.2 è piuttosto complicato nella sua formattazione. Se si desidera inserire un numero normale, posizionarlo 1prima di esso.

Fondamentalmente, questo analizza tutti i personaggi che hanno un aggiornamento (tutti tranne µe »), quindi trova tutti i set di tre di questo personaggio e li sostituisce con il carattere potenziato. L'ordinamento dopo ciascuno .replaceera il modo migliore per assicurarsi che funzionasse sempre correttamente, quindi era un bonus automatico. Il bonus 1.2 era un po 'più difficile, ma l'ho risolto in 45 byte. Il bonus di 1,5 non ne vale assolutamente la pena, poiché richiede una tonnellata in più di codifica e almeno raddoppierebbe la lunghezza.

Come sempre, i suggerimenti sono i benvenuti!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.