><>, 438(削除) 438 (削除ここまで) 365 bytes
x|o<"Yep"0x1+!
x|^"Most likely"0\aa+%3+&
x|^"Signs point to yes"+>:&:&g1-o1
x|^"As I see it, yes"Zfq
x|^"Without a doubt"Nptu!mjlfmz
x|^"Ask again later"Tjhot!qpjou!up!zft
x|^"Don't count on it"Bt!J!tff!ju-!zft
x|^"Cannot predict now"Xjuipvu!b!epvcu
x|^"Very doubtful"Ju(t!dfsubjo
x|^"My reply is no"Pvumppl!hppe
x|^"My sources say no"Zft!efgjojufmz
x|^"Outlook not so good"Zpv!nbz!sfmz!po!ju
x|^"Reply hazy try again"Ju!jt!efdjefemz!tp
x|^"Better not tell you now"Btl!bhbjo!mbufs
x|^"Concentrate and ask again"Epo(u!dpvou!po!ju
x|^"It's certain"Dboopu!qsfejdu!opx
x|^"Outlook good"Wfsz!epvcugvm
x|^"Yes definitely"Nz!sfqmz!jt!op
x|^"You may rely on it"Nz!tpvsdft!tbz!op
x|^"It is decidedly so"Sfqmz!ib{z!usz!bhbjo
Cfuufs!opu!ufmm!zpv!opx
Dpodfousbuf!boe!btl!bhbjo
Pvumppl!opu!tp!hppe
Not that interesting, but(削除) Not that interesting (削除ここまで) Now shorter than most solutions without compressed strings! I think it's also the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
Some explanationExplanation:
The pointer starts going right atAll the first line.messages are stored on the lines starting with xZfq changes the pointer to a random cardinal direction. If it goes up or down, it just encounters a differentbut with each character incremented by one (so xZfq is Yes). If it goes right, it bounces off theThe first line |0x1+! and hits the samerandomly either increments a number (initially x0. If it goes left), resets it wraps around and pushes that line's text to the stack. Most lines then hit the same track of ^1 which changesor exits the direction to upwardsloop. This loops over the o onWhen we get to the firstsecond line, which outputswe modulo this random number by 20 (though to get higher than that, would be like a one in a million chance), and add 3 to get the stack until emptyline number. The special case is theThen we push a counter starting at Yep0 line, which hasand move to the horizontal loopthird line, where we print each character subtracting one from each, where we finally terminate by trying to print |o<-1 insteadas a character.
><>, 438 bytes
x|o<"Yep"
x|^"Most likely"
x|^"Signs point to yes"
x|^"As I see it, yes"
x|^"Without a doubt"
x|^"Ask again later"
x|^"Don't count on it"
x|^"Cannot predict now"
x|^"Very doubtful"
x|^"My reply is no"
x|^"My sources say no"
x|^"Outlook not so good"
x|^"Reply hazy try again"
x|^"Better not tell you now"
x|^"Concentrate and ask again"
x|^"It's certain"
x|^"Outlook good"
x|^"Yes definitely"
x|^"You may rely on it"
x|^"It is decidedly so"
Not that interesting, but I think it's the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
Some explanation:
The pointer starts going right at the first line. x changes the pointer to a random cardinal direction. If it goes up or down, it just encounters a different x. If it goes right, it bounces off the | and hits the same x. If it goes left, it wraps around and pushes that line's text to the stack. Most lines then hit the same track of ^ which changes the direction to upwards. This loops over the o on the first line, which outputs the stack until empty. The special case is the Yep line, which has the horizontal loop |o< instead.
><>, (削除) 438 (削除ここまで) 365 bytes
0x1+!
0\aa+%3+&
+>:&:&g1-o1
Zfq
Nptu!mjlfmz
Tjhot!qpjou!up!zft
Bt!J!tff!ju-!zft
Xjuipvu!b!epvcu
Ju(t!dfsubjo
Pvumppl!hppe
Zft!efgjojufmz
Zpv!nbz!sfmz!po!ju
Ju!jt!efdjefemz!tp
Btl!bhbjo!mbufs
Epo(u!dpvou!po!ju
Dboopu!qsfejdu!opx
Wfsz!epvcugvm
Nz!sfqmz!jt!op
Nz!tpvsdft!tbz!op
Sfqmz!ib{z!usz!bhbjo
Cfuufs!opu!ufmm!zpv!opx
Dpodfousbuf!boe!btl!bhbjo
Pvumppl!opu!tp!hppe
(削除) Not that interesting (削除ここまで) Now shorter than most solutions without compressed strings! I think it's also the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
Explanation:
All the messages are stored on the lines starting with Zfq, but with each character incremented by one (so Zfq is Yes). The first line 0x1+! randomly either increments a number (initially 0), resets it to 1 or exits the loop. When we get to the second line, we modulo this random number by 20 (though to get higher than that, would be like a one in a million chance), and add 3 to get the line number. Then we push a counter starting at 0, and move to the third line, where we print each character subtracting one from each, where we finally terminate by trying to print -1 as a character.
><>, 438 bytes
x|o<"Yep"
x|^"Most likely"
x|^"Signs point to yes"
x|^"As I see it, yes"
x|^"Without a doubt"
x|^"Ask again later"
x|^"Don't count on it"
x|^"Cannot predict now"
x|^"Very doubtful"
x|^"My reply is no"
x|^"My sources say no"
x|^"Outlook not so good"
x|^"Reply hazy try again"
x|^"Better not tell you now"
x|^"Concentrate and ask again"
x|^"It's certain"
x|^"Outlook good"
x|^"Yes definitely"
x|^"You may rely on it"
x|^"It is decidedly so"
Not that interesting, but I think it's the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
###Some explanation:
Some explanation:
The pointer starts going right at the first line. x changes the pointer to a random cardinal direction. If it goes up or down, it just encounters a different x. If it goes right, it bounces off the | and hits the same x. If it goes left, it wraps around and pushes that line's text to the stack. Most lines then hit the same track of ^ which changes the direction to upwards. This loops over the o on the first line, which outputs the stack until empty. The special case is the Yep line, which has the horizontal loop |o< instead.
><>, 438 bytes
x|o<"Yep"
x|^"Most likely"
x|^"Signs point to yes"
x|^"As I see it, yes"
x|^"Without a doubt"
x|^"Ask again later"
x|^"Don't count on it"
x|^"Cannot predict now"
x|^"Very doubtful"
x|^"My reply is no"
x|^"My sources say no"
x|^"Outlook not so good"
x|^"Reply hazy try again"
x|^"Better not tell you now"
x|^"Concentrate and ask again"
x|^"It's certain"
x|^"Outlook good"
x|^"Yes definitely"
x|^"You may rely on it"
x|^"It is decidedly so"
Not that interesting, but I think it's the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
###Some explanation:
The pointer starts going right at the first line. x changes the pointer to a random cardinal direction. If it goes up or down, it just encounters a different x. If it goes right, it bounces off the | and hits the same x. If it goes left, it wraps around and pushes that line's text to the stack. Most lines then hit the same track of ^ which changes the direction to upwards. This loops over the o on the first line, which outputs the stack until empty. The special case is the Yep line, which has the horizontal loop |o< instead.
><>, 438 bytes
x|o<"Yep"
x|^"Most likely"
x|^"Signs point to yes"
x|^"As I see it, yes"
x|^"Without a doubt"
x|^"Ask again later"
x|^"Don't count on it"
x|^"Cannot predict now"
x|^"Very doubtful"
x|^"My reply is no"
x|^"My sources say no"
x|^"Outlook not so good"
x|^"Reply hazy try again"
x|^"Better not tell you now"
x|^"Concentrate and ask again"
x|^"It's certain"
x|^"Outlook good"
x|^"Yes definitely"
x|^"You may rely on it"
x|^"It is decidedly so"
Not that interesting, but I think it's the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
Some explanation:
The pointer starts going right at the first line. x changes the pointer to a random cardinal direction. If it goes up or down, it just encounters a different x. If it goes right, it bounces off the | and hits the same x. If it goes left, it wraps around and pushes that line's text to the stack. Most lines then hit the same track of ^ which changes the direction to upwards. This loops over the o on the first line, which outputs the stack until empty. The special case is the Yep line, which has the horizontal loop |o< instead.
><>, 438 bytes
x|o<"Yep"
x|^"Most likely"
x|^"Signs point to yes"
x|^"As I see it, yes"
x|^"Without a doubt"
x|^"Ask again later"
x|^"Don't count on it"
x|^"Cannot predict now"
x|^"Very doubtful"
x|^"My reply is no"
x|^"My sources say no"
x|^"Outlook not so good"
x|^"Reply hazy try again"
x|^"Better not tell you now"
x|^"Concentrate and ask again"
x|^"It's certain"
x|^"Outlook good"
x|^"Yes definitely"
x|^"You may rely on it"
x|^"It is decidedly so"
Not that interesting, but I think it's the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
###Some explanation:
The pointer starts going right at the first line. x changes the pointer to a random cardinal direction. If it goes up or down, it just encounters a different x. If it goes right, it bounces off the | and hits the same x. If it goes left, it wraps around and pushes that line's text to the stack. Most lines then hit the same track of ^ which changes the direction to upwards. This loops over the o on the first line, which outputs the stack until empty. The special case is the Yep line, which has the horizontal loop |o< instead.
><>, 438 bytes
x|o<"Yep"
x|^"Most likely"
x|^"Signs point to yes"
x|^"As I see it, yes"
x|^"Without a doubt"
x|^"Ask again later"
x|^"Don't count on it"
x|^"Cannot predict now"
x|^"Very doubtful"
x|^"My reply is no"
x|^"My sources say no"
x|^"Outlook not so good"
x|^"Reply hazy try again"
x|^"Better not tell you now"
x|^"Concentrate and ask again"
x|^"It's certain"
x|^"Outlook good"
x|^"Yes definitely"
x|^"You may rely on it"
x|^"It is decidedly so"
Not that interesting, but I think it's the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
><>, 438 bytes
x|o<"Yep"
x|^"Most likely"
x|^"Signs point to yes"
x|^"As I see it, yes"
x|^"Without a doubt"
x|^"Ask again later"
x|^"Don't count on it"
x|^"Cannot predict now"
x|^"Very doubtful"
x|^"My reply is no"
x|^"My sources say no"
x|^"Outlook not so good"
x|^"Reply hazy try again"
x|^"Better not tell you now"
x|^"Concentrate and ask again"
x|^"It's certain"
x|^"Outlook good"
x|^"Yes definitely"
x|^"You may rely on it"
x|^"It is decidedly so"
Not that interesting, but I think it's the first answer where the randomness is not uniform. I put all the negative messages as least likely :)
###Some explanation:
The pointer starts going right at the first line. x changes the pointer to a random cardinal direction. If it goes up or down, it just encounters a different x. If it goes right, it bounces off the | and hits the same x. If it goes left, it wraps around and pushes that line's text to the stack. Most lines then hit the same track of ^ which changes the direction to upwards. This loops over the o on the first line, which outputs the stack until empty. The special case is the Yep line, which has the horizontal loop |o< instead.