 # hrodward's solution

## to Diamond in the Java Track

Published at Oct 15 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.ArrayList;
import java.util.List;

class DiamondPrinter {

private static final int A_CODE = 'A';

private String getLine(char character, int sideSpacesCount, int middleSpacesCount) {
String sideSpaces = "%" + sideSpacesCount + "s";
String middleSpaces = "%" + middleSpacesCount + "s";
if (sideSpacesCount > 0) {
if (middleSpacesCount > 0) {
return String.format(sideSpaces + "%c" + middleSpaces + "%c" + sideSpaces, " ", character, " ", character, " ");
} else {
return String.format(sideSpaces + "%c" + sideSpaces, " ", character, " ");
}
} else if (middleSpacesCount > 0) {
return String.format("%c" + middleSpaces + "%c", character, " ", character);
} else {
return String.valueOf(character);
}
}

List<String> printToList(char letter) {
List<String> diamond = new ArrayList<>();
int middleSpaces = 0;

// First half of the diamond
for (int localIdx = A_CODE; localIdx <= letter; localIdx++) {
int sideSpaces = letter - localIdx;
if (sideSpaces > 0) {
if (middleSpaces == 0) {
middleSpaces++; // first to second line
} else {
middleSpaces += 2; // rest of the lines
}
}
}

// Second half of the diamond
middleSpaces -= 2;
for (int localIdx = letter - 1; localIdx >= A_CODE; localIdx--) {
int sideSpaces = letter - localIdx;
middleSpaces -= 2;
}

return diamond;
}

}``````