Avatar of SarahEglington

SarahEglington's solution

to Diamond in the Java Track

Published at Oct 22 2019 · 0 comments
Instructions
Test suite
Solution

The diamond kata takes as its input a letter, and outputs it in a diamond shape. Given a letter, it prints a diamond starting with 'A', with the supplied letter at the widest point.

Requirements

  • The first row contains one 'A'.
  • The last row contains one 'A'.
  • All rows, except the first and last, have exactly two identical letters.
  • All rows have as many trailing spaces as leading spaces. (This might be 0).
  • The diamond is horizontally symmetric.
  • The diamond is vertically symmetric.
  • The diamond has a square shape (width equals height).
  • The letters form a diamond shape.
  • The top half has the letters in ascending order.
  • The bottom half has the letters in descending order.
  • The four corners (containing the spaces) are triangles.

Examples

In the following examples, spaces are indicated by · characters.

Diamond for letter 'A':

A

Diamond for letter 'C':

··A··
·B·B·
C···C
·B·B·
··A··

Diamond for letter 'E':

····A····
···B·B···
··C···C··
·D·····D·
E·······E
·D·····D·
··C···C··
···B·B···
····A····

Setup

Go through the setup instructions for Java to install the necessary dependencies:

https://exercism.io/tracks/java/installation

Running the tests

You can run all the tests for an exercise by entering the following in your terminal:

$ gradle test

Use gradlew.bat if you're on Windows

In the test suites all tests but the first have been skipped.

Once you get a test passing, you can enable the next one by removing the @Ignore("Remove to run test") annotation.

Source

Seb Rose http://claysnow.co.uk/recycling-tests-in-tdd/

Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

DiamondPrinterTest.java

import org.junit.Ignore;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

public class DiamondPrinterTest {

    private DiamondPrinter diamondPrinter;

    @Before
    public void setUp() {
        diamondPrinter = new DiamondPrinter();
    }

    @Test
    public void testOneByOneDiamond() {
        List<String> output = diamondPrinter.printToList('A');
        assertThat(output, is(singletonList("A")));
    }

    @Ignore("Remove to run test")
    @Test
    public void testTwoByTwoDiamond() {
        List<String> output = diamondPrinter.printToList('B');
        assertThat(output, is(asList(" A ",
                                     "B B",
                                     " A ")));
    }

    @Ignore("Remove to run test")
    @Test
    public void testThreeByThreeDiamond() {
        List<String> output = diamondPrinter.printToList('C');
        assertThat(output, is(asList("  A  ",
                                     " B B ",
                                     "C   C",
                                     " B B ",
                                     "  A  ")));
    }

    @Ignore("Remove to run test")
    @Test
    public void testFourByFourDiamond() {
        List<String> output = diamondPrinter.printToList('D');
        assertThat(output, is(asList("   A   ",
                                     "  B B  ",
                                     " C   C ",
                                     "D     D",
                                     " C   C ",
                                     "  B B  ",
                                     "   A   ")));
    }

    @Ignore("Remove to run test")
    @Test
    public void testFullDiamond() {
        List<String> output = diamondPrinter.printToList('Z');
        assertThat(output, is(asList("                         A                         ",
                                     "                        B B                        ",
                                     "                       C   C                       ",
                                     "                      D     D                      ",
                                     "                     E       E                     ",
                                     "                    F         F                    ",
                                     "                   G           G                   ",
                                     "                  H             H                  ",
                                     "                 I               I                 ",
                                     "                J                 J                ",
                                     "               K                   K               ",
                                     "              L                     L              ",
                                     "             M                       M             ",
                                     "            N                         N            ",
                                     "           O                           O           ",
                                     "          P                             P          ",
                                     "         Q                               Q         ",
                                     "        R                                 R        ",
                                     "       S                                   S       ",
                                     "      T                                     T      ",
                                     "     U                                       U     ",
                                     "    V                                         V    ",
                                     "   W                                           W   ",
                                     "  X                                             X  ",
                                     " Y                                               Y ",
                                     "Z                                                 Z",
                                     " Y                                               Y ",
                                     "  X                                             X  ",
                                     "   W                                           W   ",
                                     "    V                                         V    ",
                                     "     U                                       U     ",
                                     "      T                                     T      ",
                                     "       S                                   S       ",
                                     "        R                                 R        ",
                                     "         Q                               Q         ",
                                     "          P                             P          ",
                                     "           O                           O           ",
                                     "            N                         N            ",
                                     "             M                       M             ",
                                     "              L                     L              ",
                                     "               K                   K               ",
                                     "                J                 J                ",
                                     "                 I               I                 ",
                                     "                  H             H                  ",
                                     "                   G           G                   ",
                                     "                    F         F                    ",
                                     "                     E       E                     ",
                                     "                      D     D                      ",
                                     "                       C   C                       ",
                                     "                        B B                        ",
                                     "                         A                         ")));
    }

}
import java.util.List;
import java.util.ArrayList;

class DiamondPrinter {

    List<String> printToList(char a) {
        List<String> diamond = new ArrayList<String>();
        char upper = Character.toUpperCase(a);
        char begin = 'A';
        char currentLetter = 'A';
        char reverseLetter = upper;
        reverseLetter--;
        //String middle = Character.toString(upper);
        String innerspace = "";
        String outerspace = "";
        //String diamondLine = "";
        //int letterOrder = upper - 'A' + 1;
        int letterDifference = upper - currentLetter;
        //int diamondSize = diamond.size() - 1;
        while (currentLetter <= a) {
        for (int i = letterDifference; i > 0; i--)
            outerspace += " ";
        if (currentLetter == 'A')
            diamond.add(outerspace + currentLetter + outerspace);
        else {
            diamond.add(outerspace + currentLetter + innerspace + currentLetter + outerspace);
            innerspace += " ";
            }
        currentLetter += 1;
        letterDifference--;
        innerspace += " ";
        outerspace = "";
        }

        outerspace = "";
        innerspace = "";
        int reverseDifference = upper - begin;

        for (char b = reverseLetter; b >= begin; b--) {
            //This code section handles outer padding for all diamonds
            for (char c = reverseLetter; c < upper; c++)
                outerspace += " ";
            //This part is decreasing by 1, and works for up to 3x3 diamonds
            for (int i = reverseDifference - 1; i > 0; i--){
                innerspace += ' ';
            }
            //This section is to add extra inner padding for diamonds > 3x3
            for (char d = reverseLetter; d >= 'C'; d--) {
                innerspace += ' ';
            }
            if (reverseLetter == 'A')
                diamond.add(outerspace + reverseLetter + outerspace);
            else {
                if (upper != 'A')
                    diamond.add(outerspace + reverseLetter + innerspace + reverseLetter + outerspace);
                }
            if (upper == 'A')
                break;
            if (reverseLetter != 'A')
                reverseLetter--;
            outerspace = "";
            reverseDifference--;
            innerspace = "";
        
    }
        return diamond;
    }
}

SarahEglington's Reflection

I basically ended up treating the diamond as two triangles: one increasing, then a second, slightly smaller one decreasing. Once I thought of the diamond that way, rather than trying to handle the whole diamond at once, it became easier to manage.