diff --git a/src/DeleteCharacter.ts b/src/DeleteCharacter.ts
index 6977ebd..da38747 100644
--- a/src/DeleteCharacter.ts
+++ b/src/DeleteCharacter.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type DeleteCharacter<S extends string, C extends string> = S extends `${infer A}${C}${infer B}` ? DeleteCharacter<`${A}${B}`, C> : S;
+import { DeleteCharacter } from "./solutions/DeleteCharacter";
 
 type T01 = Assert<Equals<DeleteCharacter<"hello world", "o">, "hell wrld">>;
 type T02 = Assert<Equals<DeleteCharacter<"hate this challenge", "h">, "ate tis callenge">>;
diff --git a/src/EachAsSingle.ts b/src/EachAsSingle.ts
index f31c8f9..5d431be 100644
--- a/src/EachAsSingle.ts
+++ b/src/EachAsSingle.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals, Never } from "./common";
-
-type EachAsSingle<T> = T extends T ? { wrapped: T } : never;
+import { EachAsSingle } from "./solutions/EachAsSingle";
 
 type T01 = Assert<
     Equals<
diff --git a/src/FirstFew.ts b/src/FirstFew.ts
index 96715da..3b9e301 100644
--- a/src/FirstFew.ts
+++ b/src/FirstFew.ts
@@ -11,13 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-import { Increment, UnknownArray } from "./utility";
-
-type FirstFew<T extends UnknownArray, N extends number = 0, R extends UnknownArray = [], I extends number = 0> = I extends N
-    ? R
-    : T[I] extends undefined
-    ? R
-    : FirstFew<T, N, [...R, T[I]], Increment[I]>;
+import { FirstFew } from "./solutions/FirstFew";
 
 type T01 = Assert<Equals<FirstFew<[1, 2, 3, 4, 5], 3>, [1, 2, 3]>>;
 type T02 = Assert<Equals<FirstFew<[], 0>, []>>;
diff --git a/src/IncludesString.ts b/src/IncludesString.ts
index d0c8f8e..b3f8ce0 100644
--- a/src/IncludesString.ts
+++ b/src/IncludesString.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type IncludesString<S extends string, C extends string> = S extends `${string}${C}${string}` ? true : false;
+import { IncludesString } from "./solutions/IncludesString";
 
 type T01 = Assert<Equals<IncludesString<"a long string for testing", "string" | "for">, true>>;
 type T02 = Assert<Equals<IncludesString<"a long string for testing", "ing">, true>>;
diff --git a/src/IsEven.ts b/src/IsEven.ts
index 2be251d..534c414 100644
--- a/src/IsEven.ts
+++ b/src/IsEven.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type IsEven<N extends number> = `${N}` extends `${string}${"0" | "2" | "4" | "6" | "8"}` ? true : false;
+import { IsEven } from "./solutions/IsEven";
 
 type T01 = Assert<Equals<IsEven<0>, true>>;
 type T02 = Assert<Equals<IsEven<42>, true>>;
diff --git a/src/IsNever.ts b/src/IsNever.ts
index 8d672d3..894ca79 100644
--- a/src/IsNever.ts
+++ b/src/IsNever.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type IsNever<T> = [T] extends [never] ? true : false;
+import { IsNever } from "./solutions/IsNever";
 
 type T01 = Assert<Equals<IsNever<void>, false>>;
 type T02 = Assert<Equals<IsNever<unknown>, false>>;
diff --git a/src/IsNotNumberLiteral.ts b/src/IsNotNumberLiteral.ts
index 4659e1f..efcf1c8 100644
--- a/src/IsNotNumberLiteral.ts
+++ b/src/IsNotNumberLiteral.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type IsNotNumberLiteral<T> = T extends number ? (0 extends T ? (1 extends T ? false : true) : true) : never;
+import { IsNotNumberLiteral } from "./solutions/IsNotNumberLiteral";
 
 type T01 = Assert<Equals<IsNotNumberLiteral<number>, false>>;
 type T02 = Assert<Equals<IsNotNumberLiteral<string>, never>>;
diff --git a/src/MakeExciting.ts b/src/MakeExciting.ts
index 6ebec1c..9b2d5af 100644
--- a/src/MakeExciting.ts
+++ b/src/MakeExciting.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type MakeExciting<S extends string> = `${S}!`;
+import { MakeExciting } from "./solutions/MakeExciting";
 
 type T01 = Assert<Equals<MakeExciting<"hello world">, "hello world!">>;
 type T02 = Assert<Equals<MakeExciting<"">, "!">>;
diff --git a/src/MergeSort.ts b/src/MergeSort.ts
index 3cae757..4459374 100644
--- a/src/MergeSort.ts
+++ b/src/MergeSort.ts
@@ -11,49 +11,7 @@
  */
 
 import { Assert, Equals, Unreadonly } from "./common";
-import { Decrement, UnknownArray } from "./utility";
-
-type GreaterThan<A extends number, B extends number> = A extends B ? false : B extends 0 ? true : A extends 0 ? false : GreaterThan<Decrement[A], Decrement[B]>;
-
-type Merge<Left extends UnknownArray, Right extends UnknownArray, Result extends UnknownArray = readonly []> = Left extends readonly []
-    ? readonly [...Result, ...Right]
-    : Right extends readonly []
-    ? readonly [...Result, ...Left]
-    : Left extends readonly [infer LFirst, ...infer LRest]
-    ? Right extends readonly [infer RFirst, ...infer RRest]
-        ? RFirst extends number
-            ? LFirst extends number
-                ? GreaterThan<RFirst, LFirst> extends true
-                    ? Merge<LRest, Right, readonly [...Result, LFirst]>
-                    : Merge<Left, RRest, readonly [...Result, RFirst]>
-                : never
-            : never
-        : never
-    : never;
-
-type Halves<
-    Target extends UnknownArray,
-    Left extends UnknownArray = readonly [],
-    Right extends UnknownArray = readonly []
-> = `${Target["length"]}` extends `${string}${"1" | "3" | "5" | "7" | "9"}`
-    ? Target extends readonly [...infer Rest, infer Last]
-        ? Halves<Rest, readonly [], readonly [Last]>
-        : never
-    : Target extends readonly []
-    ? readonly [Left, Right]
-    : Target extends readonly [infer LFirst, ...infer Rest, infer RFirst]
-    ? Halves<Rest, readonly [...Left, LFirst], readonly [RFirst, ...Right]>
-    : never;
-
-type MergeSort<M extends UnknownArray> = M extends readonly [] | readonly [unknown]
-    ? M
-    : Halves<M> extends readonly [infer Left, infer Right]
-    ? Left extends UnknownArray
-        ? Right extends UnknownArray
-            ? Merge<MergeSort<Left>, MergeSort<Right>>
-            : never
-        : never
-    : never;
+import { MergeSort } from "./solutions/MergeSort";
 
 type T01 = Assert<Equals<Unreadonly<MergeSort<[1, 2, 3]>>, [1, 2, 3]>>;
 type T02 = Assert<Equals<Unreadonly<MergeSort<[1, 2, 3, 4, 5]>>, [1, 2, 3, 4, 5]>>;
diff --git a/src/MiddleCharacter.ts b/src/MiddleCharacter.ts
index a59adec..3f271da 100644
--- a/src/MiddleCharacter.ts
+++ b/src/MiddleCharacter.ts
@@ -11,35 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-import { UnknownArray } from "./utility";
-
-type Split<S extends string, R extends UnknownArray = readonly []> = S extends `${infer C}${infer M}` ? Split<M, readonly [...R, C]> : R;
-
-type IsOdd<N extends number> = `${N}` extends `${string}${"1" | "3" | "5" | "7" | "9"}` ? true : false;
-
-type Halves<Target extends UnknownArray, Left extends UnknownArray = readonly [], Right extends UnknownArray = readonly []> = IsOdd<
-    Target["length"]
-> extends true
-    ? Target extends readonly [...infer Rest, infer Last]
-        ? Halves<Rest, readonly [], readonly [Last]>
-        : never
-    : Target extends readonly []
-    ? readonly [Left, Right]
-    : Target extends readonly [infer LFirst, ...infer Rest, infer RFirst]
-    ? Halves<Rest, readonly [...Left, LFirst], readonly [RFirst, ...Right]>
-    : never;
-
-type MiddleCharacter<S extends string> = IsOdd<Split<S>["length"]> extends true
-    ? Halves<Split<S>> extends readonly [unknown, readonly [infer C, ...unknown[]]]
-        ? C
-        : never
-    : Halves<Split<S>> extends readonly [readonly [...unknown[], infer A], readonly [infer B, ...unknown[]]]
-    ? A extends string
-        ? B extends string
-            ? `${A}${B}`
-            : never
-        : never
-    : "";
+import { MiddleCharacter } from "./solutions/MiddleCharacter";
 
 type T01 = Assert<Equals<MiddleCharacter<"challenge">, "l">>;
 type T02 = Assert<Equals<MiddleCharacter<"challenger">, "le">>;
diff --git a/src/NoOverlappingKeys.ts b/src/NoOverlappingKeys.ts
index f748d3d..ea8ac1c 100644
--- a/src/NoOverlappingKeys.ts
+++ b/src/NoOverlappingKeys.ts
@@ -11,14 +11,7 @@
  */
 
 import { Assert, Equals, Never } from "./common";
-
-type NoOverlappingKeys<A, B> = [
-    {
-        [K in keyof A]: K extends keyof B ? true : never;
-    }[keyof A]
-] extends [never]
-    ? A & B
-    : never;
+import { NoOverlappingKeys } from "./solutions/NoOverlappingKeys";
 
 type T01 = Assert<Equals<NoOverlappingKeys<{}, {}>, {}>>;
 type T02 = Assert<Equals<Never<NoOverlappingKeys<{ foo: number }, { foo: string }>>, true>>;
diff --git a/src/PeriodsToUnderscores.ts b/src/PeriodsToUnderscores.ts
index 2043839..61e4af7 100644
--- a/src/PeriodsToUnderscores.ts
+++ b/src/PeriodsToUnderscores.ts
@@ -11,8 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type PeriodsToUnderscores<S extends string> = S extends `${infer A}.${infer B}` ? `${A}_${PeriodsToUnderscores<B>}` : S;
+import { PeriodsToUnderscores } from "./solutions/PeriodsToUnderscores";
 
 type T01 = Assert<Equals<PeriodsToUnderscores<"a.b.c">, "a_b_c">>;
 type T02 = Assert<Equals<PeriodsToUnderscores<"">, "">>;
diff --git a/src/ReverseTuple.ts b/src/ReverseTuple.ts
index 7fd3395..4202734 100644
--- a/src/ReverseTuple.ts
+++ b/src/ReverseTuple.ts
@@ -11,11 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-import { RetainMutablity, UnknownArray } from "./utility";
-
-type ReverseTuple<A, R extends UnknownArray = []> = A extends readonly [infer First, ...infer Rest]
-    ? ReverseTuple<RetainMutablity<Rest, A>, [First, ...R]>
-    : RetainMutablity<R, A>;
+import { ReverseTuple } from "./solutions/ReverseTuple";
 
 type T01 = Assert<Equals<ReverseTuple<[1, 2, 3]>, [3, 2, 1]>>;
 type T02 = Assert<Equals<ReverseTuple<[3, 2, 1]>, [1, 2, 3]>>;
diff --git a/src/RoughlyIncludes.ts b/src/RoughlyIncludes.ts
index 21024d9..0506b5b 100644
--- a/src/RoughlyIncludes.ts
+++ b/src/RoughlyIncludes.ts
@@ -11,10 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-
-type MakeMatcher<S extends string, R extends string = `${string}`> = S extends `${infer C}${infer M}` ? MakeMatcher<M, `${R}${C}${string}`> : R;
-
-type RoughlyIncludes<Source extends string, Target extends string> = Source extends MakeMatcher<Target> ? true : false;
+import { RoughlyIncludes } from "./solutions/RoughlyIncludes";
 
 type T01 = Assert<Equals<RoughlyIncludes<"hhhhhhheeeeelllllllllllooooo", "hello">, true>>;
 type T02 = Assert<Equals<RoughlyIncludes<"hhhhhhhlllllllllllooooo", "hello">, false>>;
diff --git a/src/SplitString.ts b/src/SplitString.ts
index fb4ffdc..bd97582 100644
--- a/src/SplitString.ts
+++ b/src/SplitString.ts
@@ -11,9 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-import { UnknownArray } from "./utility";
-
-type SplitString<S extends string, R extends UnknownArray = []> = S extends `${infer C}${infer M}` ? SplitString<M, [...R, C]> : R;
+import { SplitString } from "./solutions/SplitString";
 
 type T01 = Assert<Equals<SplitString<"hi!">, ["h", "i", "!"]>>;
 type T02 = Assert<Equals<SplitString<"">, []>>;
diff --git a/src/SwapIndices.ts b/src/SwapIndices.ts
index 48bb86b..3855789 100644
--- a/src/SwapIndices.ts
+++ b/src/SwapIndices.ts
@@ -11,11 +11,7 @@
  */
 
 import { Assert, Equals } from "./common";
-import { UnknownArray } from "./utility";
-
-type SwapIndices<A extends UnknownArray, T extends number, S extends number> = {
-    [K in keyof A]: `${T}` extends K ? A[S] : `${S}` extends K ? A[T] : A[K];
-};
+import { SwapIndices } from "./solutions/SwapIndices";
 
 type T01 = Assert<Equals<SwapIndices<[1, 2, 3], 0, 2>, [3, 2, 1]>>;
 type T02 = Assert<Equals<SwapIndices<[1, 2, 3], 0, 1>, [2, 1, 3]>>;
diff --git a/src/solutions/DeleteCharacter.ts b/src/solutions/DeleteCharacter.ts
new file mode 100644
index 0000000..e8cc4c5
--- /dev/null
+++ b/src/solutions/DeleteCharacter.ts
@@ -0,0 +1 @@
+export type DeleteCharacter<S extends string, C extends string> = S extends `${infer A}${C}${infer B}` ? DeleteCharacter<`${A}${B}`, C> : S;
\ No newline at end of file
diff --git a/src/solutions/EachAsSingle.ts b/src/solutions/EachAsSingle.ts
new file mode 100644
index 0000000..9f194d2
--- /dev/null
+++ b/src/solutions/EachAsSingle.ts
@@ -0,0 +1 @@
+export type EachAsSingle<T> = T extends T ? { wrapped: T } : never;
\ No newline at end of file
diff --git a/src/solutions/FirstFew.ts b/src/solutions/FirstFew.ts
new file mode 100644
index 0000000..52dd6b3
--- /dev/null
+++ b/src/solutions/FirstFew.ts
@@ -0,0 +1,7 @@
+import { Increment, UnknownArray } from "../utility";
+
+export type FirstFew<T extends UnknownArray, N extends number = 0, R extends UnknownArray = [], I extends number = 0> = I extends N
+    ? R
+    : T[I] extends undefined
+    ? R
+    : FirstFew<T, N, [...R, T[I]], Increment[I]>;
\ No newline at end of file
diff --git a/src/solutions/IncludesString.ts b/src/solutions/IncludesString.ts
new file mode 100644
index 0000000..eedbc47
--- /dev/null
+++ b/src/solutions/IncludesString.ts
@@ -0,0 +1 @@
+export type IncludesString<S extends string, C extends string> = S extends `${string}${C}${string}` ? true : false;
\ No newline at end of file
diff --git a/src/solutions/IsEven.ts b/src/solutions/IsEven.ts
new file mode 100644
index 0000000..378bcb2
--- /dev/null
+++ b/src/solutions/IsEven.ts
@@ -0,0 +1 @@
+export type IsEven<N extends number> = `${N}` extends `${string}${"0" | "2" | "4" | "6" | "8"}` ? true : false;
\ No newline at end of file
diff --git a/src/solutions/IsNever.ts b/src/solutions/IsNever.ts
new file mode 100644
index 0000000..82aa15a
--- /dev/null
+++ b/src/solutions/IsNever.ts
@@ -0,0 +1 @@
+export type IsNever<T> = [T] extends [never] ? true : false;
\ No newline at end of file
diff --git a/src/solutions/IsNotNumberLiteral.ts b/src/solutions/IsNotNumberLiteral.ts
new file mode 100644
index 0000000..b5c3573
--- /dev/null
+++ b/src/solutions/IsNotNumberLiteral.ts
@@ -0,0 +1 @@
+export type IsNotNumberLiteral<T> = T extends number ? (0 extends T ? (1 extends T ? false : true) : true) : never;
\ No newline at end of file
diff --git a/src/solutions/MakeExciting.ts b/src/solutions/MakeExciting.ts
new file mode 100644
index 0000000..e7cbfeb
--- /dev/null
+++ b/src/solutions/MakeExciting.ts
@@ -0,0 +1 @@
+export type MakeExciting<S extends string> = `${S}!`;
\ No newline at end of file
diff --git a/src/solutions/MergeSort.ts b/src/solutions/MergeSort.ts
new file mode 100644
index 0000000..a7e64da
--- /dev/null
+++ b/src/solutions/MergeSort.ts
@@ -0,0 +1,43 @@
+import { Decrement, UnknownArray } from "../utility";
+
+type GreaterThan<A extends number, B extends number> = A extends B ? false : B extends 0 ? true : A extends 0 ? false : GreaterThan<Decrement[A], Decrement[B]>;
+
+type Merge<Left extends UnknownArray, Right extends UnknownArray, Result extends UnknownArray = readonly []> = Left extends readonly []
+    ? readonly [...Result, ...Right]
+    : Right extends readonly []
+    ? readonly [...Result, ...Left]
+    : Left extends readonly [infer LFirst, ...infer LRest]
+    ? Right extends readonly [infer RFirst, ...infer RRest]
+        ? RFirst extends number
+            ? LFirst extends number
+                ? GreaterThan<RFirst, LFirst> extends true
+                    ? Merge<LRest, Right, readonly [...Result, LFirst]>
+                    : Merge<Left, RRest, readonly [...Result, RFirst]>
+                : never
+            : never
+        : never
+    : never;
+
+type Halves<
+    Target extends UnknownArray,
+    Left extends UnknownArray = readonly [],
+    Right extends UnknownArray = readonly []
+> = `${Target["length"]}` extends `${string}${"1" | "3" | "5" | "7" | "9"}`
+    ? Target extends readonly [...infer Rest, infer Last]
+        ? Halves<Rest, readonly [], readonly [Last]>
+        : never
+    : Target extends readonly []
+    ? readonly [Left, Right]
+    : Target extends readonly [infer LFirst, ...infer Rest, infer RFirst]
+    ? Halves<Rest, readonly [...Left, LFirst], readonly [RFirst, ...Right]>
+    : never;
+
+export type MergeSort<M extends UnknownArray> = M extends readonly [] | readonly [unknown]
+    ? M
+    : Halves<M> extends readonly [infer Left, infer Right]
+    ? Left extends UnknownArray
+        ? Right extends UnknownArray
+            ? Merge<MergeSort<Left>, MergeSort<Right>>
+            : never
+        : never
+    : never;
\ No newline at end of file
diff --git a/src/solutions/MiddleCharacter.ts b/src/solutions/MiddleCharacter.ts
new file mode 100644
index 0000000..38f25e4
--- /dev/null
+++ b/src/solutions/MiddleCharacter.ts
@@ -0,0 +1,29 @@
+import { UnknownArray } from "../utility";
+
+type Split<S extends string, R extends UnknownArray = readonly []> = S extends `${infer C}${infer M}` ? Split<M, readonly [...R, C]> : R;
+
+type IsOdd<N extends number> = `${N}` extends `${string}${"1" | "3" | "5" | "7" | "9"}` ? true : false;
+
+type Halves<Target extends UnknownArray, Left extends UnknownArray = readonly [], Right extends UnknownArray = readonly []> = IsOdd<
+    Target["length"]
+> extends true
+    ? Target extends readonly [...infer Rest, infer Last]
+        ? Halves<Rest, readonly [], readonly [Last]>
+        : never
+    : Target extends readonly []
+    ? readonly [Left, Right]
+    : Target extends readonly [infer LFirst, ...infer Rest, infer RFirst]
+    ? Halves<Rest, readonly [...Left, LFirst], readonly [RFirst, ...Right]>
+    : never;
+
+export type MiddleCharacter<S extends string> = IsOdd<Split<S>["length"]> extends true
+    ? Halves<Split<S>> extends readonly [unknown, readonly [infer C, ...unknown[]]]
+        ? C
+        : never
+    : Halves<Split<S>> extends readonly [readonly [...unknown[], infer A], readonly [infer B, ...unknown[]]]
+    ? A extends string
+        ? B extends string
+            ? `${A}${B}`
+            : never
+        : never
+    : "";
\ No newline at end of file
diff --git a/src/solutions/NoOverlappingKeys.ts b/src/solutions/NoOverlappingKeys.ts
new file mode 100644
index 0000000..6264d59
--- /dev/null
+++ b/src/solutions/NoOverlappingKeys.ts
@@ -0,0 +1,7 @@
+export type NoOverlappingKeys<A, B> = [
+    {
+        [K in keyof A]: K extends keyof B ? true : never;
+    }[keyof A]
+] extends [never]
+    ? A & B
+    : never;
\ No newline at end of file
diff --git a/src/solutions/PeriodsToUnderscores.ts b/src/solutions/PeriodsToUnderscores.ts
new file mode 100644
index 0000000..2c28137
--- /dev/null
+++ b/src/solutions/PeriodsToUnderscores.ts
@@ -0,0 +1 @@
+export type PeriodsToUnderscores<S extends string> = S extends `${infer A}.${infer B}` ? `${A}_${PeriodsToUnderscores<B>}` : S;
\ No newline at end of file
diff --git a/src/solutions/ReverseTuple.ts b/src/solutions/ReverseTuple.ts
new file mode 100644
index 0000000..a872f70
--- /dev/null
+++ b/src/solutions/ReverseTuple.ts
@@ -0,0 +1,5 @@
+import { RetainMutablity, UnknownArray } from "../utility";
+
+export type ReverseTuple<A, R extends UnknownArray = []> = A extends readonly [infer First, ...infer Rest]
+    ? ReverseTuple<RetainMutablity<Rest, A>, [First, ...R]>
+    : RetainMutablity<R, A>;
\ No newline at end of file
diff --git a/src/solutions/RoughlyIncludes.ts b/src/solutions/RoughlyIncludes.ts
new file mode 100644
index 0000000..6d5c779
--- /dev/null
+++ b/src/solutions/RoughlyIncludes.ts
@@ -0,0 +1,3 @@
+type MakeMatcher<S extends string, R extends string = `${string}`> = S extends `${infer C}${infer M}` ? MakeMatcher<M, `${R}${C}${string}`> : R;
+
+export type RoughlyIncludes<Source extends string, Target extends string> = Source extends MakeMatcher<Target> ? true : false;
\ No newline at end of file
diff --git a/src/solutions/SplitString.ts b/src/solutions/SplitString.ts
new file mode 100644
index 0000000..bbc764c
--- /dev/null
+++ b/src/solutions/SplitString.ts
@@ -0,0 +1,3 @@
+import { UnknownArray } from "../utility";
+
+export type SplitString<S extends string, R extends UnknownArray = []> = S extends `${infer C}${infer M}` ? SplitString<M, [...R, C]> : R;
\ No newline at end of file
diff --git a/src/solutions/SwapIndices.ts b/src/solutions/SwapIndices.ts
new file mode 100644
index 0000000..5115d6d
--- /dev/null
+++ b/src/solutions/SwapIndices.ts
@@ -0,0 +1,5 @@
+import { UnknownArray } from "../utility";
+
+export type SwapIndices<A extends UnknownArray, T extends number, S extends number> = {
+    [K in keyof A]: `${T}` extends K ? A[S] : `${S}` extends K ? A[T] : A[K];
+};
\ No newline at end of file