diff --git a/dseki/paiza/src/Card.java b/dseki/paiza/src/Card.java
new file mode 100644
index 0000000000000000000000000000000000000000..37f7b34e5eb0cd3636f0a967752da8edef41f9a8
--- /dev/null
+++ b/dseki/paiza/src/Card.java
@@ -0,0 +1,58 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * カードクラス.
+ */
+public class Card {
+  
+  /**
+   * 二次元リストから一次元リストに変更するメソッド.
+   *
+   * @param twoDimensionalList 変更したい二次元リスト
+   * @return 変更後の一次元リストを返す
+   */
+  public List<Integer> createOneDimensionalList(final List<List<Integer>> twoDimensionalList) {
+    final List<Integer> oneDimensionalList = new ArrayList<Integer>();
+    for (int outerIndex = 0; outerIndex < twoDimensionalList.size(); outerIndex++) {
+      for (int innerIndex = 0; innerIndex < twoDimensionalList.get(outerIndex).size();
+          innerIndex++) {
+        oneDimensionalList.add(twoDimensionalList.get(outerIndex).get(innerIndex));
+      }
+    }
+    return oneDimensionalList;
+  }
+  
+  /**
+   * カードのグループを作成するメソッド.
+   *
+   * @param cardList カードが格納されているリスト
+   * @param quantityPerSet 何枚で１グループとするかを表す数値
+   * @return グループ化した二次元リストを返す
+   */
+  public List<List<Integer>> createGroupOfCards(final List<Integer> cardList, 
+                                                final int quantityPerSet) {
+    final List<List<Integer>> groupOfCards = new ArrayList<List<Integer>>();
+    for (int i = 0; i < cardList.size(); i += quantityPerSet) {
+      final int upToWhatNumber = Math.min(i + quantityPerSet, cardList.size());
+      final List<Integer> oneGroupList = cardList.subList(i, upToWhatNumber);
+      groupOfCards.add(oneGroupList);
+    }
+    return groupOfCards;
+  }
+  
+  /**
+   * カードのリストを作成するメソッド.
+   *
+   * @param numberOfCard カードの枚数
+   * @return カードが格納されているリストを返す
+   */
+  public List<Integer> createCardList(final int numberOfCard) {
+    final List<Integer> cardList = new LinkedList<>();
+    for (int i = 1; i <= numberOfCard; i++) {
+      cardList.add(i);
+    }
+    return cardList;
+  } 
+}
\ No newline at end of file
diff --git a/dseki/paiza/src/CardShuffle.java b/dseki/paiza/src/CardShuffle.java
new file mode 100644
index 0000000000000000000000000000000000000000..a557fc85505e61c6b4de0f754ddba7a425a57ec3
--- /dev/null
+++ b/dseki/paiza/src/CardShuffle.java
@@ -0,0 +1,72 @@
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * カードをシャッフルするクラス.
+ */
+public class CardShuffle {
+  private final int numberOfCard; // カードの枚数
+  private final int quantityPerSet; // 何枚のグループにするか
+  private final int numberOfShuffles; // シャッフルする回数
+  private final Card card = new Card();
+  
+  CardShuffle(final int numberOfCard, final int quantityPerSet, final int numberOfShuffles) {
+    this.numberOfCard = numberOfCard;
+    this.quantityPerSet = quantityPerSet;
+    this.numberOfShuffles = numberOfShuffles;
+  }
+  
+  /**
+   * メインメソッド.
+   */
+  public static void main(final String[] args) {
+    final Scanner sc = new Scanner(System.in);
+    final int numberOfCard = sc.nextInt();
+    final int quantityPerSet = sc.nextInt();
+    final int numberOfShuffles = sc.nextInt();
+    final CardShuffle cardShuffle = new CardShuffle(numberOfCard, 
+                                                    quantityPerSet, 
+                                                    numberOfShuffles);
+    final List<Integer> cardAfterShuffle = cardShuffle.repeatShuffle();
+    for (int card : cardAfterShuffle) {
+      System.out.println(card);
+    }
+    sc.close();
+  }
+  
+  /**
+   * カードのシャッフルを繰り返すメソッド.
+   *
+   * @return 繰り返しシャッフルを行った１次元リストを返す
+   */
+  List<Integer> repeatShuffle() {
+    final List<Integer> cardList = card.createCardList(this.numberOfCard);
+    List<List<Integer>> shuffledCardsList = shuffleCardsOnce(cardList);
+    List<Integer> cardListAfterShuffle = card.createOneDimensionalList(shuffledCardsList);
+    
+    for (int i = 0; i < this.numberOfShuffles - 1; i++) {
+      shuffledCardsList = shuffleCardsOnce(cardListAfterShuffle);
+      cardListAfterShuffle = card.createOneDimensionalList(shuffledCardsList);
+    }
+    return cardListAfterShuffle;
+  }
+  
+  /**
+   * カードを１回シャッフルするメソッド.
+   *
+   * @param cardList カードが格納されているリスト
+   * @return シャッフルしたカードがグループ化されているままの二次元リストを返す
+   */
+  private List<List<Integer>> shuffleCardsOnce(final List<Integer> cardList) {
+    final List<List<Integer>> groupOfCards = card.createGroupOfCards(cardList, this.quantityPerSet);
+    final int cardGroupSize = groupOfCards.size() - 1;
+    final int numberOfTimesToReplace = groupOfCards.size() / 2;
+    
+    for (int i = 0; i < numberOfTimesToReplace; i++) {
+      final List<Integer> strageCardList = groupOfCards.get(i);
+      groupOfCards.set(i, groupOfCards.get(cardGroupSize - i));
+      groupOfCards.set(cardGroupSize - i, strageCardList);
+    }
+    return groupOfCards;
+  }
+}
diff --git a/dseki/paiza/test/CardShuffleTest.java b/dseki/paiza/test/CardShuffleTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a3056d61555e3d74d40d29296d7db70ee023764
--- /dev/null
+++ b/dseki/paiza/test/CardShuffleTest.java
@@ -0,0 +1,24 @@
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+
+public class CardShuffleTest {
+
+  @Test
+  public void repeatShuffleで9枚のカードを3グループに分けて1回シャッフルした結果を取得する() {
+    CardShuffle cardShuffle = new CardShuffle(9, 3, 1);
+    List<Integer> actual = cardShuffle.repeatShuffle();
+    List<Integer> expected = Arrays.asList(7, 8, 9, 4, 5, 6, 1, 2, 3);
+    assertThat(actual, is(expected));
+  }
+
+  @Test
+  public void repeatShuffleで10枚のカードを3グループに分けて2回シャッフルした結果を取得する() {
+    CardShuffle cardShuffle = new CardShuffle(10, 3, 2);
+    List<Integer> actual = cardShuffle.repeatShuffle();
+    List<Integer> expected = Arrays.asList(3, 6, 1, 2, 9, 4, 5, 10, 7, 8);
+    assertThat(actual, is(expected));
+  }
+}
diff --git a/dseki/paiza/test/CardTest.java b/dseki/paiza/test/CardTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b6ee5f95749984d14aff315d019768d8d4a6ea8
--- /dev/null
+++ b/dseki/paiza/test/CardTest.java
@@ -0,0 +1,90 @@
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+
+public class CardTest {
+
+  @Test
+  public void createOneDimensionalList5枚のカードがグループ化された二次元リストを一次元リストにする() {
+    Card card = new Card();
+    List<Integer> firstList = Arrays.asList(1, 2);
+    List<Integer> secondList = Arrays.asList(3, 4);
+    List<Integer> thirdList = Arrays.asList(5);
+    List<List<Integer>> twoDimensionalList = new ArrayList<List<Integer>>();
+    twoDimensionalList.add(firstList);
+    twoDimensionalList.add(secondList);
+    twoDimensionalList.add(thirdList);
+    List<Integer> actual = card.createOneDimensionalList(twoDimensionalList);
+    List<Integer> expected = Arrays.asList(1, 2, 3, 4, 5);
+    assertThat(actual, is(expected));
+  }
+  
+  @Test
+  public void createOneDimensionalList10枚のカードがグループ化された二次元リストを一次元リストにする() {
+    Card card = new Card();
+    List<Integer> firstList = Arrays.asList(1, 2, 3);
+    List<Integer> secondList = Arrays.asList(4, 5, 6);
+    List<Integer> thirdList = Arrays.asList(7, 8, 9);
+    List<Integer> fourthList = Arrays.asList(10);
+    List<List<Integer>> twoDimensionalList = new ArrayList<List<Integer>>();
+    twoDimensionalList.add(firstList);
+    twoDimensionalList.add(secondList);
+    twoDimensionalList.add(thirdList);
+    twoDimensionalList.add(fourthList);
+    List<Integer> actual = card.createOneDimensionalList(twoDimensionalList);
+    List<Integer> expected = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    assertThat(actual, is(expected));
+  }
+
+  @Test
+  public void createGroupOfCardsで5枚のカードを2枚ずつのグループにする() {
+    Card card = new Card();
+    List<Integer> cardList = Arrays.asList(1, 2, 3, 4, 5);
+    List<List<Integer>> actual = card.createGroupOfCards(cardList, 2);
+    List<Integer> firstList = Arrays.asList(1, 2);
+    List<Integer> secondList = Arrays.asList(3, 4);
+    List<Integer> thirdList = Arrays.asList(5);
+    List<List<Integer>> expected = new ArrayList<List<Integer>>();
+    expected.add(firstList);
+    expected.add(secondList);
+    expected.add(thirdList);
+    assertThat(actual, is(expected));
+  }
+  
+  @Test
+  public void createGroupOfCardsで10枚のカードを3枚ずつのグループにする() {
+    Card card = new Card();
+    List<Integer> cardList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    List<List<Integer>> actual = card.createGroupOfCards(cardList, 3);
+    List<Integer> firstList = Arrays.asList(1, 2, 3);
+    List<Integer> secondList = Arrays.asList(4, 5, 6);
+    List<Integer> thirdList = Arrays.asList(7, 8, 9);
+    List<Integer> fourthList = Arrays.asList(10);
+    List<List<Integer>> expected = new ArrayList<List<Integer>>();
+    expected.add(firstList);
+    expected.add(secondList);
+    expected.add(thirdList);
+    expected.add(fourthList);
+    assertThat(actual, is(expected));
+  }
+
+  @Test
+  public void createCardListでカード5枚のリストを取得する() {
+    Card card = new Card();
+    List<Integer> actual = card.createCardList(5);
+    List<Integer> expected = Arrays.asList(1, 2, 3, 4, 5);
+    assertThat(actual, is(expected));
+  }
+  
+  @Test
+  public void createCardListでカード10枚のリストを取得する() {
+    Card card = new Card();
+    List<Integer> actual = card.createCardList(10);
+    List<Integer> expected = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+    assertThat(actual, is(expected));
+  }
+
+}