 # 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.

## 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')
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')
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.