);
+ if ($in !~ m/^y/i) {
+ # Exit the PLAY loop
+ print "\nIt's been fun! Bye for now.\n\n";
+ last PLAY;
+ }
+ # At this point execution goes to the start of the PLAY block,
+ # meaning a new game
+}
diff --git a/48_High_IQ/java/src/HighIQ.java b/48_High_IQ/java/src/HighIQ.java
new file mode 100644
index 00000000..d77a2ec2
--- /dev/null
+++ b/48_High_IQ/java/src/HighIQ.java
@@ -0,0 +1,153 @@
+import java.io.PrintStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+/**
+ * Game of HighIQ
+ *
+ * Based on the Basic Game of HighIQ Here:
+ * https://github.com/coding-horror/basic-computer-games/blob/main/48_High_IQ/highiq.bas
+ *
+ * No additional functionality has been added
+ */
+public class HighIQ {
+
+ //Game board, as a map of position numbers to their values
+ private final Map board;
+
+ //Output stream
+ private final PrintStream out;
+
+ //Input scanner to use
+ private final Scanner scanner;
+
+
+ public HighIQ(Scanner scanner) {
+ out = System.out;
+ this.scanner = scanner;
+ board = new HashMap<>();
+
+ //Set of all locations to put initial pegs on
+ int[] locations = new int[]{
+ 13, 14, 15, 22, 23, 24, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 42, 43, 44, 47, 48, 49, 50, 51, 52, 53, 58, 59, 60, 67, 68, 69
+ };
+
+ for (int i : locations) {
+ board.put(i, true);
+ }
+
+ board.put(41, false);
+ }
+
+ /**
+ * Plays the actual game, from start to finish.
+ */
+ public void play() {
+ do {
+ printBoard();
+ while (!move()) {
+ out.println("ILLEGAL MOVE, TRY AGAIN...");
+ }
+ } while (!isGameFinished());
+
+ int pegCount = 0;
+ for (Integer key : board.keySet()) {
+ if (board.getOrDefault(key, false)) {
+ pegCount++;
+ }
+ }
+
+ out.println("YOU HAD " + pegCount + " PEGS REMAINING");
+
+ if (pegCount == 1) {
+ out.println("BRAVO! YOU MADE A PERFECT SCORE!");
+ out.println("SAVE THIS PAPER AS A RECORD OF YOUR ACCOMPLISHMENT!");
+ }
+ }
+
+ /**
+ * Makes an individual move
+ * @return True if the move was valid, false if the user made an error and the move is invalid
+ */
+ public boolean move() {
+ out.println("MOVE WHICH PIECE");
+ int from = scanner.nextInt();
+
+ //using the getOrDefault, which will make the statement false if it is an invalid position
+ if (!board.getOrDefault(from, false)) {
+ return false;
+ }
+
+ out.println("TO WHERE");
+ int to = scanner.nextInt();
+
+ if (board.getOrDefault(to, true)) {
+ return false;
+ }
+
+ //Do nothing if they are the same
+ if (from == to) {
+ return true;
+ }
+
+ //using the difference to check if the relative locations are valid
+ int difference = Math.abs(to - from);
+ if (difference != 2 && difference != 18) {
+ return false;
+ }
+
+ //check if there is a peg between from and to
+ if (!board.getOrDefault((to + from) / 2, false)) {
+ return false;
+ }
+
+ //Actually move
+ board.put(from,false);
+ board.put(to,true);
+ board.put((from + to) / 2, false);
+
+ return true;
+ }
+
+ /**
+ * Checks if the game is finished
+ * @return True if there are no more moves, False otherwise
+ */
+ public boolean isGameFinished() {
+ for (Integer key : board.keySet()) {
+ if (board.get(key)) {
+ //Spacing is either 1 or 9
+ //Looking to the right and down from every point, checking for both directions of movement
+ for (int space : new int[]{1, 9}) {
+ Boolean nextToPeg = board.getOrDefault(key + space, false);
+ Boolean hasMovableSpace = !board.getOrDefault(key - space, true) || !board.getOrDefault(key + space * 2, true);
+ if (nextToPeg && hasMovableSpace) {
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ public void printBoard() {
+ for (int i = 0; i < 7; i++) {
+ for (int j = 11; j < 18; j++) {
+ out.print(getChar(j + 9 * i));
+ }
+ out.println();
+ }
+ }
+
+ private char getChar(int position) {
+ Boolean value = board.get(position);
+ if (value == null) {
+ return ' ';
+ } else if (value) {
+ return '!';
+ } else {
+ return 'O';
+ }
+ }
+}
diff --git a/48_High_IQ/java/src/HighIQGame.java b/48_High_IQ/java/src/HighIQGame.java
new file mode 100644
index 00000000..43400fb3
--- /dev/null
+++ b/48_High_IQ/java/src/HighIQGame.java
@@ -0,0 +1,37 @@
+import java.util.Scanner;
+
+public class HighIQGame {
+ public static void main(String[] args) {
+
+ printInstructions();
+
+ Scanner scanner = new Scanner(System.in);
+ do {
+ new HighIQ(scanner).play();
+ System.out.println("PLAY AGAIN (YES OR NO)");
+ } while(scanner.nextLine().equalsIgnoreCase("yes"));
+ }
+
+ public static void printInstructions() {
+ System.out.println("\t\t\t H-I-Q");
+ System.out.println("CREATIVE COMPUTING MORRISTOWN, NEW JERSEY");
+ System.out.println("HERE IS THE BOARD:");
+ System.out.println(" ! ! !");
+ System.out.println(" 13 14 15\n");
+ System.out.println(" ! ! !");
+ System.out.println(" 22 23 24\n");
+ System.out.println("! ! ! ! ! ! !");
+ System.out.println("29 30 31 32 33 34 35\n");
+ System.out.println("! ! ! ! ! ! !");
+ System.out.println("38 39 40 41 42 43 44\n");
+ System.out.println("! ! ! ! ! ! !");
+ System.out.println("47 48 49 50 51 52 53\n");
+ System.out.println(" ! ! !");
+ System.out.println(" 58 59 60\n");
+ System.out.println(" ! ! !");
+ System.out.println(" 67 68 69");
+ System.out.println("TO SAVE TYPING TIME, A COMPRESSED VERSION OF THE GAME BOARD");
+ System.out.println("WILL BE USED DURING PLAY. REFER TO THE ABOVE ONE FOR PEG");
+ System.out.println("NUMBERS. OK, LET'S BEGIN.");
+ }
+}
diff --git a/54_Letter/perl/letter.pl b/54_Letter/perl/letter.pl
index 54fb5fe0..56acf533 100755
--- a/54_Letter/perl/letter.pl
+++ b/54_Letter/perl/letter.pl
@@ -5,40 +5,37 @@ print ' 'x33 . "LETTER\n";
print ' 'x15 . "CREATIVE COMPUTING MORRISTOWN, NEW JERSEY\n";
print "\n\n\n";
-print "LETTER GUESSING GAME\n"; print "\n";
+print "LETTER GUESSING GAME\n\n";
print "I'LL THINK OF A LETTER OF THE ALPHABET, A TO Z.\n";
print "TRY TO GUESS MY LETTER AND I'LL GIVE YOU CLUES\n";
print "AS TO HOW CLOSE YOU'RE GETTING TO MY LETTER.\n";
-my $A;
while (1) {
- my $L= 65+int(rand(1)*26);
- my $G= 0;
- print "\n"; print "O.K., I HAVE A LETTER. START GUESSING.\n";
+ my $letter = 65 + int(rand(26));
+ my $guesses = 0;
+ print "\nO.K., I HAVE A LETTER. START GUESSING.\n";
+ my $answer;
do {
- print "\n"; print "WHAT IS YOUR GUESS? ";
- $G=$G+1;
- chomp($A= );
- $A= ord($A);
+ print "\nWHAT IS YOUR GUESS? ";
+ $guesses++;
+ chomp($answer = );
+ $answer = ord($answer);
print "\n";
- if ($A<$L) { print "TOO LOW. TRY A HIGHER LETTER.\n"; }
- if ($A>$L) { print "TOO HIGH. TRY A LOWER LETTER.\n"; }
- } until($A eq $L);
+ print "TOO LOW. TRY A HIGHER LETTER.\n" if $answer < $letter;
+ print "TOO HIGH. TRY A LOWER LETTER.\n" if $answer > $letter;
+ } until($answer eq $letter);
- print "\n"; print "YOU GOT IT IN $G GUESSES!!\n";
+ print "\nYOU GOT IT IN $guesses GUESSES!!\n";
- if ($G<=5) {
+ if ($guesses <= 5) {
print "GOOD JOB !!!!!\n";
- for (my $N=1; $N<=15; $N++) { print chr(7); } #ASCII Bell.
- } else {
+ print chr(7) x 15; # ASCII Bell
+ } else {
print "BUT IT SHOULDN'T TAKE MORE THAN 5 GUESSES!\n";
- }
-
- print "\n";
- print "LET'S PLAN AGAIN.....\n";
}
+ print "\nLET'S PLAY AGAIN.....\n";
+}
+
exit;
-
-
diff --git a/62_Mugwump/perl/mugwump.pl b/62_Mugwump/perl/mugwump.pl
new file mode 100755
index 00000000..d02a9036
--- /dev/null
+++ b/62_Mugwump/perl/mugwump.pl
@@ -0,0 +1,96 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+
+# global variables defined here
+my(@MUGWUMP) = ();
+
+# subroutines defined here
+
+# init_mugwump: pick the random places for the Mugwumps
+sub init_mugwump() {
+ @MUGWUMP = ();
+ for (1 .. 4) {
+ push @MUGWUMP, [ int(rand 10), int(rand 10) ];
+ }
+}
+
+
+# main code starts here
+
+# print introductory text
+print <);
+ my($M,$N) = split(/,/,$in);
+ $M = int($M);
+ $N = int($N);
+
+ for my $i (0 .. $#MUGWUMP) {
+ # -1 indicates a Mugwump that was already found
+ next if $MUGWUMP[$i]->[0] == -1;
+
+ if ($MUGWUMP[$i]->[0] == $M && $MUGWUMP[$i]->[1] == $N) {
+ $MUGWUMP[$i]->[0] = -1;
+ printf("You have found Mugwump %d\n", $i+1);
+ } else {
+ my $d = sqrt(($MUGWUMP[$i]->[0] - $M) ** 2 + ($MUGWUMP[$i]->[1] - $N) ** 2);
+ printf("You are %.1f units away from Mugwump %d\n", $d, $i+1);
+ }
+ }
+
+ # If a Mugwump still has not been found,
+ # go to the next turn
+ for my $j (0 .. $#MUGWUMP) {
+ if ($MUGWUMP[$j]->[0] != -1) {
+ next TURN;
+ }
+ }
+ # You win!
+ printf("You got all of them in %d %s!\n\n", $turn, ($turn == 1 ? 'turn' : 'turns'));
+ # Pass execution down to the continue block
+ next PLAY;
+
+ } # end of TURN loop
+
+ print "\nSorry, that's 10 tries. Here's where they're hiding:\n";
+ for my $i (0 .. $#MUGWUMP) {
+ printf("Mugwump %d is at (%d, %d)\n", $i+1, $MUGWUMP[$i]->[0], $MUGWUMP[$i]->[1])
+ if $MUGWUMP[$i]->[0] != -1;
+ }
+}
+continue {
+ print "\nThat was fun! Let's play again.......\n";
+ print "Four more Mugwumps are now in hiding.\n\n";
+}
+
diff --git a/65_Nim/python/Traditional_NIM.py b/65_Nim/python/Traditional_NIM.py
new file mode 100644
index 00000000..3507ecc2
--- /dev/null
+++ b/65_Nim/python/Traditional_NIM.py
@@ -0,0 +1,126 @@
+import random
+
+#Class of the Game
+class NIM:
+
+ def __init__(self):
+
+ self.Piles = {
+ 1 : 7,
+ 2 : 5,
+ 3 : 3,
+ 4 : 1
+ }
+
+ def Remove_pegs(self, command):
+
+ try:
+
+ pile, num = command.split(',')
+ num = int(num)
+ pile = int(pile)
+
+ except Exception as e:
+
+ if 'not enough values' in str(e):
+ print('\nNot a valid command. Your command should be in the form of "1,3", Try Again\n')
+
+ else:
+ print('\nError, Try again\n')
+ return None
+
+ if self._command_integrity(num, pile) == True:
+ self.Piles[pile] -= num
+ else:
+ print('\nInvalid value of either Peg or Pile\n')
+
+ def get_AI_move(self):
+
+ possible_pile = []
+ for k,v in self.Piles.items():
+ if v != 0:
+ possible_pile.append(k)
+
+ pile = random.choice(possible_pile)
+
+ num = random.randint(1,self.Piles[pile])
+
+ return pile, num
+
+ def _command_integrity(self, num, pile):
+
+ if pile <= 4 and pile >= 1:
+ if num <= self.Piles[pile]:
+ return True
+
+ return False
+
+ def print_pegs(self):
+
+ for pile, peg in self.Piles.items():
+ print('Pile {} : {}'.format(pile, 'O '*peg))
+
+ def Help(self):
+
+ print('-'*10)
+ print('\nThe Game is player with a number of Piles of Objects("O" == one peg)')
+ print('\nThe Piles are arranged as given below(Tradional NIM)\n')
+ self.print_pegs()
+ print('\nAny Number of of Objects are removed one pile by "YOU" and the machine alternatively')
+ print('\nOn your turn, you may take all the objects that remain in any pile')
+ print('but you must take ATLEAST one object')
+ print('\nAnd you may take objects from only one pile on a single turn.')
+ print('\nThe winner is defined as the one that picks the last remaning object')
+ print('-'*10)
+
+ def Checkforwin(self):
+
+ sum = 0
+ for k,v in self.Piles.items():
+ sum += v
+
+ if sum == 0:
+ return True
+
+ else:
+ return False
+
+#main program
+if __name__ == "__main__":
+
+ #Game initialization
+ game = NIM()
+
+ print('Hello, This is a game of NIM')
+ help = input('Do You Need Instruction (YES or NO): ')
+
+ if help == 'yes' or help == 'YES' or help == 'Yes':
+
+ #Printing Game Instruction
+ game.Help()
+
+ #Start game loop
+ input('\nPress Enter to start the Game:\n')
+ End = False
+ while True:
+
+ game.print_pegs()
+
+ #Players Move
+ command = input('\nYOUR MOVE - Number of PILE, Number of Object? ')
+ game.Remove_pegs(command)
+ End = game.Checkforwin()
+ if End == True:
+ print('\nPlayer Wins the Game, Congratulations!!')
+ input('\nPress any key to exit')
+ break
+
+ #Computers Move
+ command = game.get_AI_move()
+ print('\nA.I MOVE - A.I Removed {} pegs from Pile {}'.format(command[1],command[0]))
+ game.Remove_pegs(str(command[0]) +',' + str(command[1]))
+ End = game.Checkforwin()
+ if End == True:
+ print('\nComputer Wins the Game, Better Luck Next Time\n')
+ input('Press any key to exit')
+ break
diff --git a/81_Splat/java/README.md b/81_Splat/java/README.md
index 51edd8d4..b8998fa6 100644
--- a/81_Splat/java/README.md
+++ b/81_Splat/java/README.md
@@ -1,3 +1,3 @@
Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html)
-Conversion to [Oracle Java](https://openjdk.java.net/)
+Conversion to [Java](https://openjdk.java.net/)
diff --git a/81_Splat/java/src/Splat.java b/81_Splat/java/src/Splat.java
new file mode 100644
index 00000000..e042c326
--- /dev/null
+++ b/81_Splat/java/src/Splat.java
@@ -0,0 +1,357 @@
+import java.util.*;
+
+/**
+ * SPLAT simulates a parachute jump in which you try to open your parachute at the last possible moment without going
+ * splat! You may select your own terminal velocity or let the computer do it for you. You many also select the
+ * acceleration due to gravity or, again, let the computer do it in which case you might wind up on any of eight
+ * planets (out to Neptune), the moon, or the sun.
+ *
+ * The computer then tells you the height you’re jumping from and asks for the seconds of free fall. It then divides
+ * your free fall time into eight intervals and gives you progress reports on your way down. The computer also keeps
+ * track of all prior jumps in the array A and lets you know how you compared with previous successful jumps. If you
+ * want to recall information from previous runs, then you should store array A in a disk or take file and read it
+ * before each run.
+ *
+ * John Yegge created this program while at the Oak Ridge Associated Universities.
+ *
+ * Ported from BASIC by jason plumb (@breedx2)
+ *
+ */
+public class Splat {
+ private static final Random random = new Random();
+ private final Scanner scanner = new Scanner(System.in);
+ private final List pastSuccessfulJumpDistances = new ArrayList<>();
+
+ public static void main(String[] args) {
+ new Splat().run();
+ }
+
+ public void run() {
+ showIntroduction();
+
+ while (true) {
+
+ InitialJumpConditions initial = buildInitialConditions();
+
+ System.out.println();
+ System.out.printf(" ALTITUDE = %d FT\n", initial.getAltitude());
+ System.out.printf(" TERM. VELOCITY = %.2f FT/SEC +/-5%%\n", initial.getOriginalTerminalVelocity());
+ System.out.printf(" ACCELERATION = %.2f FT/SEC/SEC +/-5%%\n", initial.getOriginalAcceleration());
+
+ System.out.println("SET THE TIMER FOR YOUR FREEFALL.");
+ float freefallTime = promptFloat("HOW MANY SECONDS ");
+ System.out.println("HERE WE GO.\n");
+ System.out.println("TIME (SEC) DIST TO FALL (FT)");
+ System.out.println("========== =================");
+
+ JumpResult jump = executeJump(initial, freefallTime);
+ showJumpResults(initial, jump);
+
+ if (!playAgain()) {
+ System.out.println("SSSSSSSSSS.");
+ return;
+ }
+ }
+ }
+
+ private void showIntroduction() {
+ System.out.printf("%33s%s\n", " ", "SPLAT");
+ System.out.printf("%15s%s\n", " ", "CREATIVE COMPUTING MORRISTOWN, NEW JERSEY");
+ System.out.print("\n\n\n");
+ System.out.println("WELCOME TO 'SPLAT' -- THE GAME THAT SIMULATES A PARACHUTE");
+ System.out.println("JUMP. TRY TO OPEN YOUR CHUTE AT THE LAST POSSIBLE");
+ System.out.println("MOMENT WITHOUT GOING SPLAT.");
+ }
+
+ private InitialJumpConditions buildInitialConditions() {
+ System.out.print("\n\n");
+ float terminalVelocity = promptTerminalVelocity();
+ float acceleration = promptGravitationalAcceleration();
+ return InitialJumpConditions.create(terminalVelocity, acceleration);
+ }
+
+ private float promptTerminalVelocity() {
+ if (askYesNo("SELECT YOUR OWN TERMINAL VELOCITY")) {
+ float terminalVelocity = promptFloat("WHAT TERMINAL VELOCITY (MI/HR) ");
+ return mphToFeetPerSec(terminalVelocity);
+ }
+ float terminalVelocity = (int) (1000 * random.nextFloat());
+ System.out.printf("OK. TERMINAL VELOCITY = %.2f MI/HR\n", terminalVelocity);
+ return mphToFeetPerSec(terminalVelocity);
+ }
+
+ private float promptFloat(String prompt){
+ while(true){
+ System.out.print(prompt);
+ try {
+ return scanner.nextFloat();
+ } catch (Exception e) {
+ scanner.next(); // clear current input
+ }
+ }
+ }
+
+ private float promptGravitationalAcceleration() {
+ if (askYesNo("WANT TO SELECT ACCELERATION DUE TO GRAVITY")) {
+ return promptFloat("WHAT ACCELERATION (FT/SEC/SEC) ");
+ }
+ return chooseRandomAcceleration();
+ }
+
+ private JumpResult executeJump(InitialJumpConditions initial, float chuteOpenTime) {
+ JumpResult jump = new JumpResult(initial.getAltitude());
+ for (float time = 0.0f; time < chuteOpenTime; time += chuteOpenTime / 8) {
+ if (!jump.hasReachedTerminalVelocity() && time > initial.getTimeOfTerminalAccelerationReached()) {
+ jump.setReachedTerminalVelocity();
+ System.out.printf("TERMINAL VELOCITY REACHED AT T PLUS %f SECONDS.\n", initial.getTimeOfTerminalAccelerationReached());
+ }
+ float newDistance = computeDistance(initial, time, jump.hasReachedTerminalVelocity());
+ jump.setDistance(newDistance);
+
+ if (jump.isSplat()) {
+ return jump;
+ }
+ System.out.printf("%10.2f %f\n", time, jump.getDistance());
+ }
+ return jump;
+ }
+
+ private float computeDistance(InitialJumpConditions initial, float i, boolean hasReachedTerminalVelocity) {
+ final float V = initial.getTerminalVelocity();
+ final float A = initial.getAcceleration();
+ if (hasReachedTerminalVelocity) {
+ return initial.getAltitude() - ((V * V / (2 * A)) + (V * (i - (V / A))));
+ }
+ return initial.getAltitude() - ((A / 2) * i * i);
+ }
+
+ private void showJumpResults(InitialJumpConditions initial, JumpResult jump) {
+ if (jump.isSplat()) {
+ showSplatMessage(initial, jump);
+ showCleverSplatMessage();
+ return;
+ }
+ System.out.println("CHUTE OPEN");
+ int worseJumpCount = countWorseHistoricalJumps(jump);
+ int successfulJumpCt = pastSuccessfulJumpDistances.size();
+ pastSuccessfulJumpDistances.add(jump.getDistance());
+
+ if (pastSuccessfulJumpDistances.size() <= 2) {
+ List ordinals = Arrays.asList("1ST", "2ND", "3RD");
+ System.out.printf("AMAZING!!! NOT BAD FOR YOUR %s SUCCESSFUL JUMP!!!\n", ordinals.get(successfulJumpCt));
+ return;
+ }
+
+ int betterThanCount = successfulJumpCt - worseJumpCount;
+ if (betterThanCount <= 0.1 * successfulJumpCt) {
+ System.out.printf("WOW! THAT'S SOME JUMPING. OF THE %d SUCCESSFUL JUMPS\n", successfulJumpCt);
+ System.out.printf("BEFORE YOURS, ONLY %d OPENED THEIR CHUTES LOWER THAN\n", betterThanCount);
+ System.out.println("YOU DID.");
+ } else if (betterThanCount <= 0.25 * successfulJumpCt) {
+ System.out.printf("PRETTY GOOD! %d SUCCESSFUL JUMPS PRECEDED YOURS AND ONLY\n", successfulJumpCt);
+ System.out.printf("%d OF THEM GOT LOWER THAN YOU DID BEFORE THEIR CHUTES\n", betterThanCount);
+ System.out.println("OPENED.");
+ } else if (betterThanCount <= 0.5 * successfulJumpCt) {
+ System.out.printf("NOT BAD. THERE HAVE BEEN %d SUCCESSFUL JUMPS BEFORE YOURS.\n", successfulJumpCt);
+ System.out.printf("YOU WERE BEATEN OUT BY %d OF THEM.\n", betterThanCount);
+ } else if (betterThanCount <= 0.75 * successfulJumpCt) {
+ System.out.printf("CONSERVATIVE, AREN'T YOU? YOU RANKED ONLY %d IN THE\n", betterThanCount);
+ System.out.printf("%d SUCCESSFUL JUMPS BEFORE YOURS.\n", successfulJumpCt);
+ } else if (betterThanCount <= -0.9 * successfulJumpCt) {
+ System.out.println("HUMPH! DON'T YOU HAVE ANY SPORTING BLOOD? THERE WERE");
+ System.out.printf("%d SUCCESSFUL JUMPS BEFORE YOURS AND YOU CAME IN %d JUMPS\n", successfulJumpCt, worseJumpCount);
+ System.out.println("BETTER THAN THE WORST. SHAPE UP!!!\n");
+ } else {
+ System.out.printf("HEY! YOU PULLED THE RIP CORD MUCH TOO SOON. %d SUCCESSFUL\n", successfulJumpCt);
+ System.out.printf("JUMPS BEFORE YOURS AND YOU CAME IN NUMBER %d! GET WITH IT!\n", betterThanCount);
+ }
+ }
+
+ private void showSplatMessage(InitialJumpConditions initial, JumpResult jump) {
+ double timeOfSplat = computeTimeOfSplat(initial, jump);
+ System.out.printf("%10.2f SPLAT\n", timeOfSplat);
+ }
+
+ /**
+ * Returns the number of jumps for which this jump was better
+ */
+ private double computeTimeOfSplat(InitialJumpConditions initial, JumpResult jump) {
+ final float V = initial.getTerminalVelocity();
+ final float A = initial.getAcceleration();
+ if (jump.hasReachedTerminalVelocity()) {
+ return (V / A) + ((initial.getAltitude() - (V * V / (2 * A))) / V);
+ }
+ return Math.sqrt(2 * initial.getAltitude() / A);
+ }
+
+ private int countWorseHistoricalJumps(JumpResult jump) {
+ return (int) pastSuccessfulJumpDistances.stream()
+ .filter(distance -> jump.getDistance() < distance)
+ .count();
+ }
+
+ private void showCleverSplatMessage() {
+ List messages = Arrays.asList(
+ "REQUIESCAT IN PACE.",
+ "MAY THE ANGEL OF HEAVEN LEAD YOU INTO PARADISE.",
+ "REST IN PEACE.",
+ "SON-OF-A-GUN.",
+ "#$%&&%!$",
+ "A KICK IN THE PANTS IS A BOOST IF YOU'RE HEADED RIGHT.",
+ "HMMM. SHOULD HAVE PICKED A SHORTER TIME.",
+ "MUTTER. MUTTER. MUTTER.",
+ "PUSHING UP DAISIES.",
+ "EASY COME, EASY GO."
+ );
+ System.out.println(messages.get(random.nextInt(10)));
+ }
+
+ private boolean playAgain() {
+ if (askYesNo("DO YOU WANT TO PLAY AGAIN ")) {
+ return true;
+ }
+ return askYesNo("PLEASE");
+ }
+
+ private float mphToFeetPerSec(float speed) {
+ return speed * (5280.0f / 3600.0f);
+ }
+
+ private boolean askYesNo(String prompt) {
+ System.out.printf("%s (YES OR NO) ", prompt);
+ while (true) {
+ String answer = scanner.next();
+ switch (answer) {
+ case "YES":
+ return true;
+ case "NO":
+ return false;
+ default:
+ System.out.print("YES OR NO ");
+ }
+ }
+ }
+
+ private float chooseRandomAcceleration() {
+ Planet planet = Planet.pickRandom();
+ System.out.printf("%s %s. ACCELERATION=%.2f FT/SEC/SEC.\n", planet.getMessage(), planet.name(), planet.getAcceleration());
+ return planet.getAcceleration();
+ }
+
+ enum Planet {
+ MERCURY("FINE. YOU'RE ON", 12.2f),
+ VENUS("ALL RIGHT. YOU'RE ON", 28.3f),
+ EARTH("THEN YOU'RE ON", 32.16f),
+ MOON("FINE. YOU'RE ON THE", 5.15f),
+ MARS("ALL RIGHT. YOU'RE ON", 12.5f),
+ JUPITER("THEN YOU'RE ON", 85.2f),
+ SATURN("FINE. YOU'RE ON", 37.6f),
+ URANUS("ALL RIGHT. YOU'RE ON", 33.8f),
+ NEPTUNE("THEN YOU'RE ON", 39.6f),
+ SUN("FINE. YOU'RE ON THE", 896.0f);
+
+ private static final Random random = new Random();
+ private final String message;
+ private final float acceleration;
+
+ Planet(String message, float acceleration) {
+ this.message = message;
+ this.acceleration = acceleration;
+ }
+
+ static Planet pickRandom() {
+ return values()[random.nextInt(Planet.values().length)];
+ }
+
+ String getMessage() {
+ return message;
+ }
+
+ float getAcceleration() {
+ return acceleration;
+ }
+ }
+
+ // Mutable
+ static class JumpResult {
+ private boolean reachedTerminalVelocity = false;
+ private float distance; // from the ground
+
+ public JumpResult(float distance) {
+ this.distance = distance;
+ }
+
+ boolean isSplat() {
+ return distance <= 0;
+ }
+
+ boolean hasReachedTerminalVelocity() {
+ return reachedTerminalVelocity;
+ }
+
+ float getDistance() {
+ return distance;
+ }
+
+ void setDistance(float distance) {
+ this.distance = distance;
+ }
+
+ void setReachedTerminalVelocity() {
+ reachedTerminalVelocity = true;
+ }
+ }
+
+ // Immutable
+ static class InitialJumpConditions {
+ private final float originalTerminalVelocity;
+ private final float originalAcceleration;
+ private final float terminalVelocity;
+ private final float acceleration;
+ private final int altitude;
+
+ private InitialJumpConditions(float originalTerminalVelocity, float originalAcceleration,
+ float terminalVelocity, float acceleration, int altitude) {
+ this.originalTerminalVelocity = originalTerminalVelocity;
+ this.originalAcceleration = originalAcceleration;
+ this.terminalVelocity = terminalVelocity;
+ this.acceleration = acceleration;
+ this.altitude = altitude;
+ }
+
+ // Create initial jump conditions with adjusted velocity/acceleration and a random initial altitude
+ private static InitialJumpConditions create(float terminalVelocity, float gravitationalAcceleration) {
+ final int altitude = (int) (9001.0f * random.nextFloat() + 1000);
+ return new InitialJumpConditions(terminalVelocity, gravitationalAcceleration,
+ plusMinus5Percent(terminalVelocity), plusMinus5Percent(gravitationalAcceleration), altitude);
+ }
+
+ private static float plusMinus5Percent(float value) {
+ return value + ((value * random.nextFloat()) / 20.0f) - ((value * random.nextFloat()) / 20.0f);
+ }
+
+ float getOriginalTerminalVelocity() {
+ return originalTerminalVelocity;
+ }
+
+ float getOriginalAcceleration() {
+ return originalAcceleration;
+ }
+
+ float getTerminalVelocity() {
+ return terminalVelocity;
+ }
+
+ float getAcceleration() {
+ return acceleration;
+ }
+
+ int getAltitude() {
+ return altitude;
+ }
+
+ float getTimeOfTerminalAccelerationReached() {
+ return terminalVelocity / acceleration;
+ }
+ }
+}
\ No newline at end of file
diff --git a/84_Super_Star_Trek/README.md b/84_Super_Star_Trek/README.md
index 4a96f528..77fae3d8 100644
--- a/84_Super_Star_Trek/README.md
+++ b/84_Super_Star_Trek/README.md
@@ -101,4 +101,4 @@ Instructions in this directory at
instructions.txt
#### External Links
- - Super Star Trek in C++ : https://www.codeproject.com/Articles/28399/The-Object-Oriented-Text-Star-Trek-Game-in-C
+ - C++: https://www.codeproject.com/Articles/28399/The-Object-Oriented-Text-Star-Trek-Game-in-C
diff --git a/85_Synonym/kotlin/README.md b/85_Synonym/kotlin/README.md
new file mode 100644
index 00000000..f43a5b70
--- /dev/null
+++ b/85_Synonym/kotlin/README.md
@@ -0,0 +1,3 @@
+Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html)
+
+Conversion to [Kotlin](https://kotlinlang.org/)
diff --git a/85_Synonym/kotlin/Synonym.kt b/85_Synonym/kotlin/Synonym.kt
new file mode 100644
index 00000000..386a2525
--- /dev/null
+++ b/85_Synonym/kotlin/Synonym.kt
@@ -0,0 +1,73 @@
+/**
+ * Game of Synonym
+ *
+ *
+ * Based on the Basic game of Synonym here
+ * https://github.com/coding-horror/basic-computer-games/blob/main/85%20Synonym/synonym.bas
+ *
+ *
+ * Note: The idea was to create a version of the 1970's Basic game in Java, without introducing
+ * new features - no additional text, error checking, etc has been added.
+ */
+
+fun main() {
+ println(introText)
+ synonyms.forEach {
+ it.testUser()
+ }
+ println("SYNONYM DRILL COMPLETED.")
+}
+// We could put this inside of SynonymList, but this keeps the core implementation
+// right here at the top
+private fun SynonymList.testUser() {
+ do {
+ val answer = ask(" WHAT IS A SYNONYM OF $word ? ")
+ when {
+ answer == "HELP" ->
+ println("""**** A SYNONYM OF $word IS ${synonyms.random()}.""")
+ synonyms.contains(answer) ->
+ println(AFFIRMATIONS.random())
+ else ->
+ println("TRY AGAIN.")
+ }
+ } while (!synonyms.contains(answer))
+}
+
+val introText = """
+${tab(33)}SYNONYM
+${tab(15)}CREATIVE COMPUTING MORRISTOWN, NEW JERSEY
+A SYNONYM OF A WORD MEANS ANOTHER WORD IN THE ENGLISH
+LANGUAGE WHICH HAS THE SAME OR VERY NEARLY THE SAME
+ MEANING.
+I CHOOSE A WORD -- YOU TYPE A SYNONYM.
+IF YOU CAN'T THINK OF A SYNONYM, TYPE THE WORD 'HELP'
+AND I WILL TELL YOU A SYNONYM.
+
+ """
+
+// prints a question and reads a string (and converts to uppercase)
+private fun ask(text: String): String {
+ print(text)
+ return readln().uppercase()
+}
+
+// Just like TAB in BASIC
+private fun tab(spaces: Int): String = " ".repeat(spaces)
+
+val AFFIRMATIONS = arrayOf("RIGHT", "CORRECT", "FINE", "GOOD!", "CHECK")
+
+// List of words and synonyms
+private val synonyms = listOf(
+ SynonymList("FIRST", listOf("START", "BEGINNING", "ONSET", "INITIAL")),
+ SynonymList("SIMILAR", listOf("SAME", "LIKE", "RESEMBLING")),
+ SynonymList("MODEL", listOf("PATTERN", "PROTOTYPE", "STANDARD", "CRITERION")),
+ SynonymList("SMALL", listOf("INSIGNIFICANT", "LITTLE", "TINY", "MINUTE")),
+ SynonymList("STOP", listOf("HALT", "STAY", "ARREST", "CHECK", "STANDSTILL")),
+ SynonymList("HOUSE", listOf("DWELLING", "RESIDENCE", "DOMICILE", "LODGING", "HABITATION")),
+ SynonymList("PIT", listOf("HOLE", "HOLLOW", "WELL", "GULF", "CHASM", "ABYSS")),
+ SynonymList("PUSH", listOf("SHOVE", "THRUST", "PROD", "POKE", "BUTT", "PRESS")),
+ SynonymList("RED", listOf("ROUGE", "SCARLET", "CRIMSON", "FLAME", "RUBY")),
+ SynonymList("PAIN", listOf("SUFFERING", "HURT", "MISERY", "DISTRESS", "ACHE", "DISCOMFORT"))
+)
+
+class SynonymList(val word: String, val synonyms: List)
\ No newline at end of file
diff --git a/85_Synonym/ruby/synonim.rb b/85_Synonym/ruby/synonim.rb
new file mode 100644
index 00000000..92d2e8c7
--- /dev/null
+++ b/85_Synonym/ruby/synonim.rb
@@ -0,0 +1,94 @@
+########################################################
+#
+# Synonym
+#
+# From Basic Computer Games (1978)
+#
+# A synonym of a word is another word (in the English language) which has the same,
+# or very nearly the same, meaning. This program tests your knowledge of synonyms
+# of a few common words.
+#
+# The computer chooses a word and asks you for a synonym. The computer then tells
+# you whether you’re right or wrong. If you can’t think of a synonym, type “HELP”
+# which causes a synonym to be printed.
+# You may put in words of your choice in the data statements.
+# The number following DATA in Statement 500 is the total number of data statements.
+# In each data statement, the first number is the number of words in that statement.
+#
+# Can you think of a way to make this into a more general kind of CAI program for any subject?
+# Walt Koetke of Lexington High School, Massachusetts created this program.
+#
+#
+########################################################
+
+puts <<~INSTRUCTIONS
+ SYNONYM
+ CREATIVE COMPUTING MORRISTOWN, NEW JERSEY
+
+A SYNONYM OF A WORD MEANS ANOTHER WORD IN THE ENGLISH
+LANGUAGE WHICH HAS THE SAME OR VERY NEARLY THE SAME MEANING.
+I CHOOSE A WORD -- YOU TYPE A SYNONYM.
+IF YOU CAN'T THINK OF A SYNONYM, TYPE THE WORD 'HELP'
+AND I WILL TELL YOU A SYNONYM.
+
+
+INSTRUCTIONS
+
+right_words = ["RIGHT", "CORRECT", "FINE", "GOOD!", "CHECK"]
+
+synonym_words = [
+ ["FIRST", "START", "BEGINNING", "ONSET", "INITIAL"],
+ ["SIMILAR", "ALIKE", "SAME", "LIKE", "RESEMBLING"],
+ ["MODEL", "PATTERN", "PROTOTYPE", "STANDARD", "CRITERION"],
+ ["SMALL", "INSIGNIFICANT", "LITTLE", "TINY", "MINUTE"],
+ ["STOP", "HALT", "STAY", "ARREST", "CHECK", "STANDSTILL"],
+ ["HOUSE", "DWELLING", "RESIDENCE", "DOMICILE", "LODGING", "HABITATION"],
+ ["PIT", "HOLE", "HOLLOW", "WELL", "GULF", "CHASM", "ABYSS"],
+ ["PUSH", "SHOVE", "THRUST", "PROD", "POKE", "BUTT", "PRESS"],
+ ["RED", "ROUGE", "SCARLET", "CRIMSON", "FLAME", "RUBY"],
+ ["PAIN", "SUFFERING", "HURT", "MISERY", "DISTRESS", "ACHE", "DISCOMFORT"],
+]
+
+synonym_words.shuffle.each {|words_ar|
+
+}
+
+
+synonym_words.each {|words_ar|
+ answer = false
+ keyword = words_ar.shift
+
+ while not answer and words_ar.length != 0
+ puts " WHAT IS A SYNONYM OF #{keyword}? "
+ inp = gets.chomp.upcase
+
+ if inp == "HELP"
+ clue = words_ar.sample
+ puts "**** A SYNONYM OF #{keyword} IS #{clue}."
+ words_ar.delete(clue)
+ elsif words_ar.include? inp
+ puts right_words.sample
+ answer = true
+ else
+ puts "TRY AGAIN."
+ end
+
+ end
+
+}
+
+puts "SYNONYM DRILL COMPLETED"
+
+
+######################################################################
+#
+# Porting notes
+#
+# There is a bug in the original program where if you keep asking for
+# synoyms of a given word it ends up running out of synonyms
+# in the array and the program crashes.
+# The bug has been fixed in this version and now when
+# it runs out of words it continues with the next
+# array.
+#
+######################################################################
diff --git a/87_3-D_Plot/d/.gitignore b/87_3-D_Plot/d/.gitignore
new file mode 100644
index 00000000..d969f6b2
--- /dev/null
+++ b/87_3-D_Plot/d/.gitignore
@@ -0,0 +1,2 @@
+*.exe
+*.obj
diff --git a/87_3-D_Plot/d/README.md b/87_3-D_Plot/d/README.md
new file mode 100644
index 00000000..8a01faf3
--- /dev/null
+++ b/87_3-D_Plot/d/README.md
@@ -0,0 +1,182 @@
+Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html)
+
+Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo).
+
+## Running the code
+
+Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler:
+```shell
+dmd -dip1000 -run threedeeplot.d
+```
+
+[Other compilers](https://dlang.org/download.html) also exist.
+
+## On rounding floating point values to integer values
+
+The D equivalent of Basic `INT` is [`floor`](https://dlang.org/phobos/std_math_rounding.html#.floor),
+which rounds towards negative infinity. If you change occurrences of `floor` to
+[`lrint`](https://dlang.org/phobos/std_math_rounding.html#.lrint), you'll see that the plots show a bit more detail,
+as is done in the bonus below.
+
+## Bonus: Self-writing programs
+
+With a small modification to the source, the program can be extended to **plot a random function**, and **print its formula**.
+
+```shell
+rdmd -dip1000 threedeeplot_random.d
+```
+(`rdmd` caches the executable, which results in speedy execution when the source does not change.)
+
+### Example output
+```
+ 3D Plot
+ (After Creative Computing Morristown, New Jersey)
+
+
+ f(z) = 30 * sin(z / 10.0)
+
+ *
+ * * * *
+ * * * * *
+ * * * * *
+ * * * * * *
+ * * * * * *
+ * * * * * **
+ * * * * * * *
+ * * * * * * **
+ * * * * * * * *
+ * * * * * * * *
+ * * * * * * * **
+ * * * * * * * * *
+ * * * * ** * * * *
+ * * * * ** * * *
+ * * * * * * * *
+ * * * * * * * *
+ * * * ** * * **
+ * * * ** * **
+ * * * * * **
+ * * * * * **
+ * * * * * **
+ * * * ** * **
+ * * * ** * * **
+ * * * * * * * *
+ * * * * * * * *
+ * * * * ** * * *
+ * * * * ** * * * *
+ * * * * * * * * *
+ * * * * * * * **
+ * * * * * * * *
+ * * * * * * * *
+ * * * * * * **
+ * * * * * * *
+ * * * * * **
+ * * * * * *
+ * * * * * *
+ * * * * *
+ * * * * *
+ * * * *
+ *
+```
+
+### Breakdown of differences
+
+Have a look at the relevant differences between `threedeeplot.d` and `threedeeplot_random.d`.
+This is the original function with the single expression that is evaluated for the plot:
+```d
+ static float fna(float z)
+ {
+ return 30.0 * exp(-z * z / 100.0);
+ }
+```
+Here `static` means that the nested function does not need acces to its enclosing scope.
+
+Now, by inserting the following:
+```d
+ enum functions = ["30.0 * exp(-z * z / 100.0)",
+ "sqrt(900.01 - z * z) * .9 - 2",
+ "30 * (cos(z / 16.0) + .5)",
+ "30 - 30 * sin(z / 18.0)",
+ "30 * exp(-cos(z / 16.0)) - 30",
+ "30 * sin(z / 10.0)"];
+
+ size_t index = uniform(0, functions.length);
+ writeln(center("f(z) = " ~ functions[index], width), "\n");
+```
+and changing the implementation of `fna` to
+```d
+ float fna(float z)
+ {
+ final switch (index)
+ {
+ static foreach (i, f; functions)
+ case i:
+ mixin("return " ~ f ~ ";");
+ }
+ }
+```
+we unlock some very special abilities of D. Let's break it down:
+
+```d
+ enum functions = ["30.0 * exp(-z * z / 100.0)", /*...*/];
+```
+This defines an array of strings, each containing a mathematical expression. Due to the `enum` keyword, this is an
+array that really only exists at compile-time.
+
+```d
+ size_t index = uniform(0, functions.length);
+```
+This defines a random index into the array. `functions.length` is evaluated at compile-time, due to D's compile-time
+function evaluation (CTFE).
+
+```d
+ writeln(center("f(z) = " ~ functions[index], width), "\n");
+```
+Unmistakenly, this prints the formula centered on a line. What happens behind the scenes is that `functions` (which
+only existed at compile-time before now) is pasted in, so that an instance of that array actually exists at run-time
+at this spot, and is instantly indexed.
+
+```d
+ float fna(float z)
+ {
+ final switch (index)
+ {
+ // ...
+ }
+ }
+```
+`static` has been dropped from the nested function because we want to evaluate `index` inside it. The function contains
+an ordinary `switch`, with `final` providing some extra robustness. It disallows a `default` case and produces an error
+when the switch doesn't handle all cases. The `switch` body is where the magic happens and consists of these three
+lines:
+```d
+ static foreach (i, f; functions)
+ case i:
+ mixin("return " ~ f ~ ";");
+```
+The `static foreach` iterates over `functions` at compile-time, producing one `case` for every element in `functions`.
+`mixin` takes a string, which is constructed at compile-time, and pastes it right into the source.
+
+In effect, the implementation of `float fna(float z)` unrolls itself into
+```d
+ float fna(float z)
+ {
+ final switch (index)
+ {
+ case 0:
+ return 30.0 * exp(-z * z / 100.0);
+ case 1:
+ return sqrt(900.01 - z * z) * .9 - 2;
+ case 2:
+ return 30 * (cos(z / 16.0) + .5);
+ case 3:
+ return 30 - 30 * sin(z / 18.0);
+ case 4:
+ return 30 * exp(-cos(z / 16.0)) - 30;
+ case 5:
+ return 30 * sin(z / 10.0)";
+ }
+ }
+```
+
+So if you feel like adding another function, all you need to do is append it to the `functions` array, and the rest of
+the program *rewrites itself...*
diff --git a/87_3-D_Plot/d/threedeeplot.d b/87_3-D_Plot/d/threedeeplot.d
new file mode 100644
index 00000000..a3660321
--- /dev/null
+++ b/87_3-D_Plot/d/threedeeplot.d
@@ -0,0 +1,35 @@
+@safe: // Make @safe the default for this file, enforcing memory-safety.
+import std.stdio, std.string, std.math, std.range, std.conv, std.algorithm;
+
+void main()
+{
+ enum width = 80;
+ writeln(center("3D Plot", width));
+ writeln(center("(After Creative Computing Morristown, New Jersey)\n\n\n", width));
+
+ static float fna(float z)
+ {
+ return 30.0 * exp(-z * z / 100.0);
+ }
+
+ char[] row;
+
+ for (float x = -30.0; x <= 30.0; x += 1.5)
+ {
+ size_t max_z = 0L;
+ auto y1 = 5 * floor((sqrt(900 - x * x)) / 5.0);
+ for (float y = y1; y >= -y1; y -= 5)
+ {
+ auto z = to!size_t(max(0, floor(25 + fna(sqrt(x * x + y * y)) - .7 * y)));
+ if (z > max_z) // Visible
+ {
+ max_z = z;
+ if (z + 1 > row.length) // row needs to grow
+ row ~= ' '.repeat(z + 1 - row.length).array;
+ row[z] = '*';
+ }
+ }
+ writeln(row);
+ row = null;
+ }
+}
diff --git a/87_3-D_Plot/d/threedeeplot_random.d b/87_3-D_Plot/d/threedeeplot_random.d
new file mode 100644
index 00000000..3db1a2cd
--- /dev/null
+++ b/87_3-D_Plot/d/threedeeplot_random.d
@@ -0,0 +1,50 @@
+@safe: // Make @safe the default for this file, enforcing memory-safety.
+import std.stdio, std.string, std.math, std.range, std.conv, std.random, std.algorithm;
+
+void main()
+{
+ enum width = 80;
+ writeln(center("3D Plot", width));
+ writeln(center("(After Creative Computing Morristown, New Jersey)\n\n", width));
+
+ enum functions = ["30.0 * exp(-z * z / 100.0)",
+ "sqrt(900.01 - z * z) * .9 - 2",
+ "30 * (cos(z / 16.0) + .5)",
+ "30 - 30 * sin(z / 18.0)",
+ "30 * exp(-cos(z / 16.0)) - 30",
+ "30 * sin(z / 10.0)"];
+
+ size_t index = uniform(0, functions.length);
+ writeln(center("f(z) = " ~ functions[index], width), "\n");
+
+ float fna(float z)
+ {
+ final switch (index)
+ {
+ static foreach (i, f; functions)
+ case i:
+ mixin("return " ~ f ~ ";");
+ }
+ }
+
+ char[] row;
+
+ for (float x = -30.0; x <= 30.0; x += 1.5)
+ {
+ size_t max_z = 0L;
+ auto y1 = 5 * lrint((sqrt(900 - x * x)) / 5.0);
+ for (float y = y1; y >= -y1; y -= 5)
+ {
+ auto z = to!size_t(max(0, lrint(25 + fna(sqrt(x * x + y * y)) - .7 * y)));
+ if (z > max_z) // Visible
+ {
+ max_z = z;
+ if (z + 1 > row.length) // row needs to grow
+ row ~= ' '.repeat(z + 1 - row.length).array;
+ row[z] = '*';
+ }
+ }
+ writeln(row);
+ row = null;
+ }
+}
diff --git a/94_War/javascript/war.js b/94_War/javascript/war.js
index eb74fb0c..ededa1ed 100644
--- a/94_War/javascript/war.js
+++ b/94_War/javascript/war.js
@@ -1,60 +1,95 @@
// WAR
//
-// Converted from BASIC to Javascript by Oscar Toledo G. (nanochess)
+// Original conversion from BASIC to Javascript by Oscar Toledo G. (nanochess)
//
-function print(str)
-{
+function print(str) {
document.getElementById("output").appendChild(document.createTextNode(str));
}
-function input()
-{
- var input_element;
- var input_str;
-
- return new Promise(function (resolve) {
- input_element = document.createElement("INPUT");
-
- print("? ");
- input_element.setAttribute("type", "text");
- input_element.setAttribute("length", "50");
- document.getElementById("output").appendChild(input_element);
- input_element.focus();
- input_str = undefined;
- input_element.addEventListener("keydown", function (event) {
- if (event.keyCode == 13) {
- input_str = input_element.value;
- document.getElementById("output").removeChild(input_element);
- print(input_str);
- print("\n");
- resolve(input_str);
- }
- });
- });
-}
-
-function tab(space)
-{
- var str = "";
- while (space-- > 0)
+function tab(space) {
+ let str = "";
+ while (space-- > 0) {
str += " ";
+ }
return str;
}
-var a = [, "S-2","H-2","C-2","D-2","S-3","H-3","C-3","D-3",
- "S-4","H-4","C-4","D-4","S-5","H-5","C-5","D-5",
- "S-6","H-6","C-6","D-6","S-7","H-7","C-7","D-7",
- "S-8","H-8","C-8","D-8","S-9","H-9","C-9","D-9",
- "S-10","H-10","C-10","D-10","S-J","H-J","C-J","D-J",
- "S-Q","H-Q","C-Q","D-Q","S-K","H-K","C-K","D-K",
- "S-A","H-A","C-A","D-A"];
+function input() {
+ return new Promise(function (resolve) {
+ const input_element = document.createElement("INPUT");
-var l = [];
+ print("? ");
+ input_element.setAttribute("type", "text");
+ input_element.setAttribute("length", "50");
+ document.getElementById("output").appendChild(input_element);
+ input_element.focus();
+ input_element.addEventListener("keydown", function (event) {
+ if (event.keyCode == 13) {
+ const input_str = input_element.value;
+ document.getElementById("output").removeChild(input_element);
+ print(input_str);
+ print("\n");
+ resolve(input_str);
+ }
+ });
+ });
+}
-// Main control section
-async function main()
-{
+async function askYesOrNo(question) {
+ while (1) {
+ print(question);
+ const str = await input();
+ if (str == "YES") {
+ return true;
+ }
+ else if (str == "NO") {
+ return false;
+ }
+ else {
+ print("YES OR NO, PLEASE. ");
+ }
+ }
+}
+
+async function askAboutInstructions() {
+ const playerWantsInstructions = await askYesOrNo("DO YOU WANT DIRECTIONS");
+ if (playerWantsInstructions) {
+ print("THE COMPUTER GIVES YOU AND IT A 'CARD'. THE HIGHER CARD\n");
+ print("(NUMERICALLY) WINS. THE GAME ENDS WHEN YOU CHOOSE NOT TO\n");
+ print("CONTINUE OR WHEN YOU HAVE FINISHED THE PACK.\n");
+ }
+ print("\n");
+ print("\n");
+}
+
+function createGameDeck(cards, gameSize) {
+ const deck = [];
+ const deckSize = cards.length;
+ for (let j = 0; j < gameSize; j++) {
+ let card;
+
+ // Compute a new card index until we find one that isn't already in the new deck
+ do {
+ card = Math.floor(deckSize * Math.random());
+ } while (deck.includes(card));
+ deck.push(card);
+ }
+ return deck;
+}
+
+function computeCardValue(cardIndex) {
+ return Math.floor(cardIndex / 4);
+}
+
+function printGameOver(playerScore, computerScore) {
+ print("\n");
+ print("\n");
+ print(`WE HAVE RUN OUT OF CARDS. FINAL SCORE: YOU: ${playerScore} THE COMPUTER: ${computerScore}\n`);
+ print("\n");
+}
+
+function printTitle() {
print(tab(33) + "WAR\n");
print(tab(15) + "CREATIVE COMPUTING MORRISTOWN, NEW JERSEY\n");
print("\n");
@@ -62,72 +97,65 @@ async function main()
print("\n");
print("THIS IS THE CARD GAME OF WAR. EACH CARD IS GIVEN BY SUIT-#\n");
print("AS S-7 FOR SPADE 7. ");
- while (1) {
- print("DO YOU WANT DIRECTIONS");
- str = await input();
- if (str == "YES") {
- print("THE COMPUTER GIVES YOU AND IT A 'CARD'. THE HIGHER CARD\n");
- print("(NUMERICALLY) WINS. THE GAME ENDS WHEN YOU CHOOSE NOT TO\n");
- print("CONTINUE OR WHEN YOU HAVE FINISHED THE PACK.\n");
- break;
- }
- if (str == "NO")
- break;
- print("YES OR NO, PLEASE. ");
- }
- print("\n");
+}
+
+function printCards(playerCard, computerCard) {
print("\n");
+ print(`YOU: ${playerCard}\tCOMPUTER: ${computerCard}\n`);
+}
+
+const cards = [
+ "S-2", "H-2", "C-2", "D-2",
+ "S-3", "H-3", "C-3", "D-3",
+ "S-4", "H-4", "C-4", "D-4",
+ "S-5", "H-5", "C-5", "D-5",
+ "S-6", "H-6", "C-6", "D-6",
+ "S-7", "H-7", "C-7", "D-7",
+ "S-8", "H-8", "C-8", "D-8",
+ "S-9", "H-9", "C-9", "D-9",
+ "S-10", "H-10", "C-10", "D-10",
+ "S-J", "H-J", "C-J", "D-J",
+ "S-Q", "H-Q", "C-Q", "D-Q",
+ "S-K", "H-K", "C-K", "D-K",
+ "S-A", "H-A", "C-A", "D-A"
+];
+
+// Main control section
+async function main() {
+ printTitle();
+ await askAboutInstructions();
- a1 = 0;
- b1 = 0;
- p = 0;
+ let computerScore = 0;
+ let playerScore = 0;
// Generate a random deck
- for (j = 1; j <= 52; j++) {
- do {
- l[j] = Math.floor(52 * Math.random()) + 1;
- for (k = 1; k < j; k++) {
- if (l[k] == l[j]) // Already in deck?
- break;
- }
- } while (j != 1 && k < j) ;
- }
- l[j] = 0; // Mark the end of the deck
+ const gameSize = cards.length; // Number of cards to shuffle into the game deck. Can be <= cards.length.
+ const deck = createGameDeck(cards, gameSize);
+ let shouldContinuePlaying = true;
- while (1) {
- m1 = l[++p]; // Take a card
- m2 = l[++p]; // Take a card
- print("\n");
- print("YOU: " + a[m1] + "\tCOMPUTER: " + a[m2] + "\n");
- n1 = Math.floor((m1 - 0.5) / 4);
- n2 = Math.floor((m2 - 0.5) / 4);
- if (n1 < n2) {
- a1++;
- print("THE COMPUTER WINS!!! YOU HAVE " + b1 + " AND THE COMPUTER HAS " + a1 + "\n");
- } else if (n1 > n2) {
- b1++;
- print("YOU WIN. YOU HAVE " + b1 + " AND THE COMPUTER HAS " + a1 + "\n");
+ while (deck.length > 0 && shouldContinuePlaying) {
+ const playerCard = deck.shift(); // Take a card
+ const computerCard = deck.shift(); // Take a card
+ printCards(cards[playerCard], cards[computerCard]);
+
+ const playerCardValue = computeCardValue(playerCard);
+ const computerCardValue = computeCardValue(computerCard);
+ if (playerCardValue < computerCardValue) {
+ computerScore++;
+ print("THE COMPUTER WINS!!! YOU HAVE " + playerScore + " AND THE COMPUTER HAS " + computerScore + "\n");
+ } else if (playerCardValue > computerCardValue) {
+ playerScore++;
+ print("YOU WIN. YOU HAVE " + playerScore + " AND THE COMPUTER HAS " + computerScore + "\n");
} else {
print("TIE. NO SCORE CHANGE.\n");
}
- if (l[p + 1] == 0) {
- print("\n");
- print("\n");
- print("WE HAVE RUN OUT OF CARDS. FINAL SCORE: YOU: " + b1 + " THE COMPUTER: " + a1 + "\n");
- print("\n");
- break;
+
+ if (deck.length === 0) {
+ printGameOver(playerScore, computerScore);
}
- while (1) {
- print("DO YOU WANT TO CONTINUE");
- str = await input();
- if (str == "YES")
- break;
- if (str == "NO")
- break;
- print("YES OR NO, PLEASE. ");
+ else {
+ shouldContinuePlaying = await askYesOrNo("DO YOU WANT TO CONTINUE");
}
- if (str == "NO")
- break;
}
print("THANKS FOR PLAYING. IT WAS FUN.\n");
print("\n");
diff --git a/96_Word/d/.gitignore b/96_Word/d/.gitignore
new file mode 100644
index 00000000..d969f6b2
--- /dev/null
+++ b/96_Word/d/.gitignore
@@ -0,0 +1,2 @@
+*.exe
+*.obj
diff --git a/96_Word/d/README.md b/96_Word/d/README.md
new file mode 100644
index 00000000..764cb141
--- /dev/null
+++ b/96_Word/d/README.md
@@ -0,0 +1,15 @@
+Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html)
+
+Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo).
+
+The Basic original required words to be exactly five letters in length for the program to behave correctly.
+This version does not replicate that limitation, and the test for that requirement is commented out.
+
+## Running the code
+
+Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler:
+```shell
+dmd -dip1000 -run word.d
+```
+
+[Other compilers](https://dlang.org/download.html) also exist.
diff --git a/96_Word/d/word.d b/96_Word/d/word.d
new file mode 100644
index 00000000..6f4d46d6
--- /dev/null
+++ b/96_Word/d/word.d
@@ -0,0 +1,85 @@
+@safe: // Make @safe the default for this file, enforcing memory-safety.
+import std;
+
+void main()
+{
+ enum width = 80;
+ writeln(center("Word", width));
+ writeln(center("(After Creative Computing Morristown, New Jersey)\n\n\n", width));
+ writeln(wrap("I am thinking of a word -- you guess it. I will give you " ~
+ "clues to help you get it. Good luck!!\n\n", width));
+
+ string[] words = ["dinky", "smoke", "water", "grass", "train", "might", "first",
+ "candy", "champ", "would", "clump", "dopey"];
+
+ playLoop: while (true)
+ {
+ writeln("\n\nYou are starting a new game...");
+
+ string word = words[uniform(0, $-1)]; // $ is a short-hand for words.length.
+ int guesses = 0;
+ string knownLetters = '-'.repeat(word.length).array;
+
+ while (true)
+ {
+ writeln("Guess a ", word.length, " letter word");
+ string guess = readString.toLower;
+ if (guess == "?")
+ {
+ writeln("The secret word is ", word, "\n");
+ continue playLoop; // Start a new game.
+ }
+ /* Uncomment this for equivalence with Basic.
+ if (guess.length != 5)
+ {
+ writeln("You must guess a 5 letter word. Start again.");
+ continue; // Ask for new guess.
+ }
+ */
+ guesses++;
+ if (guess == word)
+ break; // Done guessing
+ string commonLetters;
+ foreach (i, wordLetter; word)
+ foreach (j, guessLetter; guess)
+ if (guessLetter == wordLetter)
+ {
+ commonLetters ~= guessLetter;
+ if (i == j)
+ knownLetters.replaceInPlace(i, i + 1, [guessLetter]);
+ }
+ writeln("There were ", commonLetters.length, " matches and the common letters were... ", commonLetters);
+ writeln("From the exact letter matches, you know................ ", knownLetters);
+ if (knownLetters == word)
+ break; // Done guessing
+ if (commonLetters.length < 2)
+ writeln("If you give up, type '?' for your next guess.");
+ writeln;
+ }
+
+ writeln("You have guessed the word. It took ", guesses, " guesses!");
+ write("\n\nWant to play again? ");
+ if (readString.toLower != "yes")
+ break; // Terminate playLoop
+ }
+}
+
+/// Read a string from standard input, stripping newline and other enclosing whitespace.
+string readString() nothrow
+{
+ try
+ return trustedReadln.strip;
+ catch (Exception) // readln throws on I/O and Unicode errors, which we handle here.
+ return "";
+}
+
+/** An @trusted wrapper around readln.
+ *
+ * This is the only function that formally requires manual review for memory-safety.
+ * [Arguably readln should be safe already](https://forum.dlang.org/post/rab398$1up$1@digitalmars.com)
+ * which would remove the need to have any @trusted code in this program.
+ */
+string trustedReadln() @trusted
+{
+ return readln;
+}
diff --git a/HOW_TO_RUN_THE_GAMES.md b/HOW_TO_RUN_THE_GAMES.md
new file mode 100644
index 00000000..44d82e98
--- /dev/null
+++ b/HOW_TO_RUN_THE_GAMES.md
@@ -0,0 +1,85 @@
+# How to run the games
+
+The games in this repository have been translated into a number of different languages. How to run them depends on the target language.
+
+## csharp
+
+### dotnet command-line
+
+The best cross-platform method for running the csharp examples is with the `dotnet` command-line tool. This can be downloaded for **MacOS**, **Windows** and **Linux** from [dotnet.microsoft.com](https://dotnet.microsoft.com/).
+
+From there, the program can be run by
+
+1. Opening a terminal window
+1. Navigating to the corresponding directory
+1. Starting with `dotnet run`
+
+### Visual Studio
+
+Alternatively, for non-dotnet compatible translations, you will need [Visual Studio](https://visualstudio.microsoft.com/vs/community/) which can be used to both open the project and run the example.
+
+1. Open the corresponding `.csproj` or `.sln` file
+1. Click `Run` from within the Visual Studio IDE
+
+## java
+
+The Java translations can be run via the command line or from an IDE such as [Eclipse](https://www.eclipse.org/downloads/packages/release/kepler/sr1/eclipse-ide-java-developers) or [IntelliJ](https://www.jetbrains.com/idea/)
+
+To run from the command line, you will need a Java SDK (eg. [Oracle JDK](https://www.oracle.com/java/technologies/downloads/) or [Open JDK](https://openjdk.java.net/)).
+
+1. Navigate to the corresponding directory.
+1. Compile the program with `javac`:
+ * eg. `javac AceyDuceyGame.java`
+1. Run the compiled program with `java`:
+ * eg. `java AceyDuceyGame`
+
+## javascript
+
+The javascript examples can be run from within your web browser:
+
+1. Simply open the corresponding `.html` file from your web browser.
+
+## pascal
+
+The pascal examples can be run using [Free Pascal](https://www.freepascal.org/). Additionally, `.lsi` project files can be opened with the [Lazarus Project IDE](https://www.lazarus-ide.org/).
+
+The pascal examples include both *simple* (single-file) and *object-oriented* (in the `/object-pascal`directories) examples.
+
+1. You can compile the program from the command line with the `fpc` command.
+ * eg. `fpc amazing.pas`
+1. The output is an executable file that can be run directly.
+
+## perl
+
+The perl translations can be run using a perl interpreter (a copy can be downloaded from [perl.org](https://www.perl.org/)) if not already installed.
+
+1. From the command-line, navigate to the corresponding directory.
+1. Invoke with the `perl` command.
+ * eg. `perl aceyducey.pl`
+
+## python
+
+The python translations can be run from the command line by using the `py` interpreter. If not already installed, a copy can be downloaded from [python.org](https://www.python.org/downloads/) for **Windows**, **MacOS** and **Linux**.
+
+1. From the command-line, navigate to the corresponding directory.
+1. Invoke with the `py` or `python` interpreter (depending on your python version).
+ * eg. `py acey_ducey_oo.py`
+ * eg. `python aceyducey.py`
+
+**Note**
+
+Some translations include multiple versions for python, such as `acey ducey` which features versions for Python 2 (`aceyducey.py`) and Python 3 (`acey_ducey.py`) as well as an extra object-oriented version (`acey_ducey_oo.py`).
+
+You can manage and use different versions of python with [pip](https://pypi.org/project/pip/).
+
+## ruby
+
+If you don't already have a ruby interpreter, you can download it from the [ruby project site](https://www.ruby-lang.org/en/).
+
+1. From the command-line, navigate to the corresponding directory.
+1. Invoke with the `ruby` tool.
+ * eg. `ruby aceyducey.rb`
+
+## vbnet
+
+Follow the same steps as for the [csharp](#csharp) translations. This can be run with `dotnet` or `Visual Studio`.