A tiny adventure
JavaScript (ES6), 244 249 267 280
Edit Saved 18 (!) bytes thx @Neil
A function with input:
- r = room content (array of 10 strings)
- k = combinations (array of string of 3 chars - source1, source2, result)
- s = inventory max size (number)
- c = commands (array of strings)
Returns true or false
(r,k,s,c,p=0,j={})=>c.some(([c,a,b])=>c<'D'?j[a]>0&j[b]>0&&!k.map(([t,u,v])=>u+t==a+b|u+t==b+a?j[j[a]=j[b]=v]=++s:0):c<'G'?j[a]>0&&!(j[++s,a]=~p):c>'G'?s&&j[a]==~p&&!(j[a]=s--):j['ABCDEFGHIJ'[a]]>0&&(p=a)>8,r.map((o,n)=>[...o].map(c=>j[c]=~n)))
See the test snippet below for a newline separated version
Test
Exec=
(r,k,s,c,p=0,j={})=>
c.some(
([c,a,b])=>
c<'D'?j[a]>0&j[b]>0&&!k.map(([t,u,v])=>u+t==a+b|u+t==b+a?j[j[a]=j[b]=v]=++s:0)
:c<'G'?j[a]>0&&!(j[++s,a]=~p)
:c>'G'?s&&j[a]==~p&&!(j[a]=s--)
:j['ABCDEFGHIJ'[a]]>0&&(p=a)>8
,r.map((o,n)=>[...o].map(c=>j[c]=~n))
)
console.log = (...x) => O.textContent += x + '\n';
;`pass J '' '' '' '' '' '' '' '' '' 0 9 PJ G9;
fail '' J '' '' '' '' '' '' '' '' 0 9 PJ G9;
pass J '' '' '' '' '' '' '' '' '' 0 9 PJ PJ G9;
fail J '' '' '' '' '' '' '' '' '' 0 9 PJ;
fail J '' '' '' '' '' '' '' '' '' 0 9 G9;
pass J '' '' '' '' '' '' '' '' '' 0 9 G9 PJ G9;
pass J '' '' '' '' '' '' '' '' '' 0 1 PJ G9;
fail J '' '' '' '' '' '' '' '' '' 0 0 PJ G9;
fail J '' '' '' '' '' '' '' '' '' 0 9 PJ DJ G9;
fail J '' '' '' '' '' '' '' '' '' 0 9 PJ PJ DJ G9;
pass J '' '' '' '' '' '' '' '' '' 0 9 PJ DJ PJ G9;
pass J '' '' '' '' '' '' '' '' '' 0 9 PJ DJ PJ G9;
pass B CJ '' '' '' '' '' '' '' '' 0 2 PB G1 DB PC PJ G9;
fail B CJ '' '' '' '' '' '' '' '' 0 2 PB G1 DB PB PC PJ G9;
pass AJ '' '' '' '' '' '' '' '' '' 0 2 PA PJ G9;
pass B D '' J '' '' '' '' '' '' 0 2 PB G1 PD G3 DB PJ G9;
fail B D '' J '' '' '' '' '' '' 0 2 PB G1 PD G2 DB PJ G9;
fail B D '' J '' '' '' '' '' '' 0 2 PB G1 PD G3 PJ G9;
fail B D J C '' '' '' '' '' '' 0 2 PB G1 PD G3 PJ G9;
pass AJ '' '' '' '' '' '' '' '' '' 0 2 PA PJ G9 G0;
fail ADJ '' '' '' '' '' '' '' '' '' 0 3 PA PD PJ G3 DJ G0 PJ G9;
pass ADJ '' '' '' '' '' '' '' '' '' 0 3 PA PD PJ G3 DJ G0 G3 PJ G9;
fail ADJ '' '' '' '' '' '' '' '' '' 0 3 PA PD PJ G3 DJ G0 DD G3 PJ G9;
pass ADJ '' '' '' '' '' '' '' '' '' 0 3 PA PD PJ DD G3 DJ G0 DD G3 PJ G9;
fail ADJ '' '' '' '' '' '' '' '' '' 0 1 PA DA DA PD PJ G9;
pass ADJ '' '' '' '' '' '' '' '' '' 0 1 PA DA DA PJ G9;
fail ABCDEFGHIKLMNOPQRSTUVWXYZ J '' '' '' '' '' '' '' '' 0 26 PA PB PC PD PE PF PG PH PI PJ PK PL PM PN PO PP PQ PR PS PT PU PV PW PX PY PZ G9;
pass ABCDEFGHIJKLMNOPQRSTUVWXYZ '' '' '' '' '' '' '' '' '' 0 26 PA PB PC PD PE PF PG PH PI PJ PK PL PM PN PO PP PQ PR PS PT PU PV PW PX PY PZ G9;
fail YZJ '' '' '' '' '' '' '' '' '' 0 2 PY PZ CYZ PJ G9;
pass YZJ '' '' '' '' '' '' '' '' '' 1 YZW 2 PY PZ CYZ PJ G9;
pass YZJ '' '' '' '' '' '' '' '' '' 1 YZW 2 PY PZ CYZ PJ CWJ G9;
fail XYZJ '' '' '' '' '' '' '' '' '' 1 YZW 2 PY PZ CYZ PX PJ G9;
fail XYZJ '' '' '' '' '' '' '' '' '' 1 YZW 2 PY PZ CYZ PX DY DZ PJ G9;
pass XYZJ '' '' '' '' '' '' '' '' '' 1 YZW 2 PY PZ CYZ PX DW PJ G9;
pass YZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 PY PZ CYZ G9;
fail YZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 CYZ G9;
pass YZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 PY PZ CYZ CYZ G9;
fail YZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 PY PZ CYZ DJ CYZ G9;
fail YZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 PY PZ CYZ DJ PY PZ CYZ G9;
fail WZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 PW PZ CYZ G9;
fail WZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 PY PZ CYZ G9;
pass YZ '' '' '' '' '' '' '' '' '' 1 YZJ 2 PY PZ CZY G9;
pass YZ '' '' '' '' '' '' '' '' '' 1 ZYJ 2 PY PZ CYZ G9;
fail YZ '' '' '' '' '' '' '' '' '' 1 YZJ 1 PY PZ CYZ G9;
fail YZ '' '' '' '' '' '' '' '' '' 1 YZJ 1 PY PZ CYZ PY PZ CYZ G9;
fail YZ '' '' '' '' '' '' '' '' '' 1 YZJ 1 PY PZ CYZ PJ G9;
fail YZ '' '' '' '' '' '' '' '' '' 1 YZJ 1 PJ G9;
pass BW UV '' '' '' '' '' '' '' '' 3 BUR WVS RSJ 2 PB PW G1 DW PU CBU DR PW PV CVW PR CRS G9;
fail BW AUV '' '' '' '' '' '' '' '' 3 BUR WVS RSJ 2 PB G1 PU CBU DR PA PB G0 DA PW G1 PV CVW PR CRS G9;
pass BCW AUV '' '' '' '' '' '' '' '' 3 CUR WVS RSJ 2 PB PC G1 DB PU CCU DR PC PA PB G0 DA PW G1 DB PV CVW PR CRS G9;
fail BCW UV '' '' '' '' '' '' '' '' 3 CUR WVS RSJ 2 PB PC G1 DB PU CCU DR PC PA PB G0 DA PW G1 DB PV CVW PR CRS G9;
fail BCW AUV '' '' '' '' '' '' '' '' 3 CUR WVS RSJ 2 PB PC G1 DB PU CCU PA PB G0 DA PW G1 DB PV CVW PR CRS G9;
fail BCW AUV '' '' '' '' '' '' '' '' 3 CUR WVS RSJ 2 PB PC G1 DB PU CCU DR PA G0 DA PW G1 DB PV CVW PR CRS G9;
fail BCW AUV '' '' '' '' '' '' '' '' 3 CUR WVS RSJ 2 PB PC G1 DB PU CCU DR PB G0 DA PW G1 DB PV CVW PR CRS G9;
fail BCW AUV '' '' '' '' '' '' '' '' 3 CUR WVS RSJ 2 PB PC G1 DB PU CCU DR PA PB G0 DA G1 DB PV CVW PR CRS G9;
fail BCW AUV '' '' '' '' '' '' '' '' 3 CUR WVS RSJ 2 PB PC G1 DB PU CCU DR PA PB G0 DA PW G1 DB CVW PR CRS G9;
pass BFK LG M N O CDE PQR U W '' 10 BPT CQS TSH HUI IWV VFA GRX MXZ ANY YZJ 5 PB PF PK G1 PL PG G6 DB DK DL G5 PC PD PE G6 DF G2 PM G6 DM DC G3 PN G4 PO G6 DN DO DD DE PB PP CBP PC PQ CCQ CTS G7 PU CUH G8 PW CWI G6 PF CVF PR PM PN CGR CMX CAN CYZ G9
fail BFK LG M N O CDE PQR U W '' 10 BPT CQS TSH HUI IWV VFA GRX MXZ ANY YZJ 5 PB PF PK G1 PL PG G6 DB DK DL G5 PC PD PE G6 DF G6 DM DC G3 PN G4 PO PM G6 DN DO DD DE PB PP CBP PC PQ CCQ CTS G7 PU CUH G8 PW CWI G6 PF CVF PR PM PN CGR CMX CAN CYZ G9`
.split(/;*\n/).map((srow,i)=>{
var row=srow.split(/\s+/),
rooms=row.slice(1,11).map(x=>x=="''"?"":x),
ncomb=+row[11],
comb=row.slice(12,12+ncomb),
isize=+row[12+ncomb],
commands=row.slice(13+ncomb),
start='['+rooms+'] ['+comb+'] '+isize+' ['+commands+']';
var result=Exec(rooms,comb,isize,commands),
ok = row[0] == ['fail','pass'][~~result]
console.log(i, ok ? 'ok':'ko', start, row[0], result)
})<pre id=O></pre>C, 338 bytes
I had a go at minifying my own test program. I think it went quite well, even if it is the longest answer so far!
#define P c[(i<j?i:j)*25+i+j]
#define F for(q=atoi(*++v);r
#define X c[r*91+i]
r,i,j,c[2405];main(q,v)char**v;{for(r=10;--r;)for(++v;i=**v;++*v)++X;++v;F<q;++r)i=**++v,j=1[*v],P=2[*v];r=9;F&&*++v;c[i=1[*v]]&&j==68?c[i]=!++X,++q:j>79&&q*X?c[i]=!--X,--q:j==71&&c[i+17]?r=57-i:j<68&&c[i]*c[j=2[*v]]&&P?c[i]=c[j]=0,c[P]=++q:0)j=**v;return r;}
This uses a few tricks to save space:
- Rooms are loaded in reverse so that checking for room 9 becomes checking for room 0, which is cheaper
- Room 9's contents never matter, so it is skipped when reading the input and used to store the inventory instead
- The room contents and item combinations are stored in the same array. Because items are stored at their ascii values, they never overlap.
Breakdown:
#define P c[(i<j?i:j)*25+i+j] // item combination lookup (input: i,j)
#define X c[r*91+i] // room item lookup (input: r,i)
r,i,j,c[2405]; // globals default to 0
main(q,v)char**v;{ // K&R syntax to save bytes
for(r=10;--r;) // Load rooms 0-8, store as 9-1
for(++v;i=**v;++*v)
++X;
++v; // Skip room 9
for(q=atoi(*++v);r<q;++r) // For each combination
i=**++v,
j=1[*v], // Use index[array] syntax to avoid (brackets)
P=2[*v]; // Record combination
r=9; // Begin in room 0 (9 in memory)
for(q=atoi(*++v); // Load inventory size
r // While not in room 9 (0 in memory)...
&&*++v; // ...and still have user commands
// (ISO C promises a NULL at the end of argv)
c[i=1[*v]]&&j==68? // If 'D'rop, and we have the item:
c[i]=!++X, // Drop it
++q: // Increase our inventory capacity
j>79&& // If 'P'ick up, and...
q // ...we have capacity in our inventory and...
*X? // ...the item is in the room:
c[i]=!--X, // Pick it up
--q: // Decrease our inventory capacity
j==71&&c[i+17]? // If 'G'o to room, and we have the key:
r=57-i: // Go to the room
j<68&& // If 'C'ombine, and...
c[i]*c[j=2[*v]] // ...we have the items and...
&&P? // ...they can be combined
c[i]=c[j]=0, // Remove the items
c[P]=++q: // Add the combined item and increase capacity
0 // Unrecognised or invalid command
)
j=**v; // 'j' is the command letter (happens first)
return r; // Return the final room (0 = truthy in shell)
}
Partially inspired by @edc65's answer.
I was so close to getting ;*++*v; and c[P][c] into the code for ultimate confusion, but unfortunately other options turned out to be shorter :(
Haskell, 354 325 323 bytes
(#)=elem
(#)=elem
(%)=filter.(/=)
m!s=g""0.zip[0..]where g _ p _[]=p>8;g i p r(c:d)|p>8=1<2|'P':[k]<-c,k#x,length i<s=g(k:i)p((p,k%x):r)d|'D':[k]<-c,k#i=g(k%i)p((p,k:x):r)d|'C':q@[k,l]<-c,k#i,l#i,[y]<-[f|[d,e,f]<-m,q==[d,e]||q==[e,d]]=g(y:k%(l%i))p r d|'G':n<-c,y<-read n,['A'..]!!y#i=g i y r d|1<2=g i p r d where Just x=lookup p r
Defines a function ! which takes in order
- the possible combinations as a list of 3 letter strings
- the maximum size of the inventory
- the rooms as a list of 9 strings
- the player commands as a list of strings
Returns True or False. Example call:
*Main> (!) ["YZW"] 2 ["YZJ","","","","","","","","",""] ["PY","PZ","CYZ","PJ","CWJ","G9"]
True
All test cases.
Many bytes are spent in carrying the game state around. Haskell cannot destructively update data structures like the rooms and inventory.
The work is done by function g which takes 4 parameters: the inventory (String), the current room (Integer), the rooms (Assoc-List, with key: room number and value: items) and the commands left (List of String).
g _ p _[] = p>8 -- base case. if no commands left, return
-- True if we are in room 9
g i p r(c:d)
| p>8 = 1<2 -- reached room 9
| 'P':[k]<-c, -- 'Pickup', if
k#x, -- key is in room and
length i<s -- inventory not full
= g(k:i)p((p,k%x):r)d -- adjust inventory and room
| 'D':[k]<-c, -- 'Drop', if
k#i -- key is in inventory
= g(k%i)p((p,k:x):r)d -- adjust inventory and room
| 'C':q@[k,l]<-c, -- 'Combine', if
k#i,l#i, -- both keys are in inventory and
[y]<-[f|[d,e,f]<-m,q==[d,e]||q==[e,d]]
-- combination is possible
= g(y:k%(l%i))p r d -- adjust inventory
| 'G':n<-c, y<-read[n], -- 'Goto', convert digit to integer
['A'..]!!y#i -- key for room is in inventory
= g i y r t -- go to room
| 1<2 -- impossible command
= g i p r d -- ignore it
Maybe the following things can save some bytes
- State Monad for the game state
A single Assoc-List for the keys (key: letter of key, value: room number withNo, constructing such an initial Assoc-List and the check for max inventory size costs more than it saves dealing with one less parameter.-1for inventory) instead of rooms/inventory