 # cmbntr's solution

## to Diamond in the Java Track

Published at Oct 06 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 static java.util.stream.Collectors.toList;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

class DiamondPrinter {

List<String> printToList(final char a) {
return printToList(IntStream.range('A', 1 + a));
}

List<String> printToList(final String txt) {
return printToList(txt.chars());
}

private static List<String> printToList(final IntStream chars) {
return printToList(collectCharacters(chars));
}

private static List<String> printToList(final List<Character> chars) {
final int len = chars.size();
if (len < 2) {
return chars.stream().map(Object::toString).collect(toList());
}
final int lineCnt = 2 * len - 1;
final String[] lines = new String[lineCnt];
for (int i = 0; i < len; i++) {
lines[i] = lines[lineCnt - i - 1] = line(chars.get(i), i, len);
}
return Arrays.asList(lines);
}

private static String line(final char c, final int idx, final int len) {
final int lineLength = 2 * len - 1;
final int outerPadding = len - idx - 1;
final int innerPadding = 2 * idx - 1;
final StringBuilder line = new StringBuilder(lineLength);
}
}

private static StringBuilder appendSpaces(final StringBuilder l, int n) {
while (n-- > 0) {
l.append(' ');
}
return l;
}

private static List<Character> collectCharacters(final IntStream chars) {
return chars.mapToObj(c -> Character.valueOf((char) c)).collect(toList());
}

}``````