# artemkorsakov's solution

## to Diamond in the Java Track

Published at Feb 05 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····
``````

# Running the tests

You can run all the tests for an exercise by entering

``````\$ gradle test
``````

## 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.Arrays;
import java.util.Collections;
import java.util.List;

import static java.util.Collections.singletonList;

class DiamondPrinter {

List<String> printToList(char a) {
if (a == 'A') {
return singletonList("A");
}

int size = (a - 'A') * 2 + 1;
List<String> firstPart = new ArrayList<>();
for (int i = 'A'; i < a; i++) {
}
List<String> result = new ArrayList<>(firstPart);
Collections.reverse(firstPart);
return result;
}

private String getRow(char a, int size) {
int numberOfSpacesInside = (a == 'A') ? 0 : ((a - 'B') * 2 + 1);
int numberOfSpacesOut = (a == 'A') ? ((size - 1) / 2) : ((size - numberOfSpacesInside - 2) / 2);
char[] charsInside = new char[numberOfSpacesInside];
Arrays.fill(charsInside, ' ');
char[] charsOut = new char[numberOfSpacesOut];
Arrays.fill(charsOut, ' ');
String centre = (a == 'A') ? "A" : a + String.valueOf(charsInside) + a;
return String.valueOf(charsOut) + centre + String.valueOf(charsOut);
}

}``````