総数

Name	#	総数	積
Moniamond	1	1	1
Diamond	2	1	2
Triamond	3	1	3
Tetriamond	4	3	12
Pentiamond	5	4	20
Hexiamond	6	12	72
Heptiamonds	7	24	168
Octiamonds	8	66	528
Enneiamonds	9	160	1440
Deciamonds	10	448	4480
-	11	1186	ry
-	12	3334	ry
-	13	9235	ry

Enneiamondsから、穴有りの図形が含まれます。

上記サイトでは、Polyiamondsの種類（数とpsの図形データ）と、穴有りの数がわかります。

充填図形が正六角形は不可能なのかな？

辺の長さ	三角の数(6*n^2)
1	6
2	24
3	54
4	96
5	150
6	216
7	294
8	384
9	486
10	600

不可能ですね。

出力結果

プログラム

// ================= Polyiamond Enumerator (Processing 4) =================
// 三角格子 (i,j,up) で polyiamond を列挙
// - 辺共有の3近傍だけで成長（頂点接触は不可）
// - 重複除去：60°回転(6通り) ＋（必要なら）鏡像も同一に
// =======================================================================

import java.util.*;

int N = 6;                    // 三角形の個数
boolean MIRROR_SAME = true;  // 鏡像も同一にするなら true（free になる）

ArrayList<HashSet<Tri>> results = new ArrayList<HashSet<Tri>>();
HashSet<String> seenKeys = new HashSet<String>();

void setup(){
  size(1200, 900);
  enumerate();
  println("polyiamonds N=" + N + "  count=" + results.size()
          + "  (mirrorSame=" + MIRROR_SAME + ")");
  noLoop();
}

void draw(){
  background(255);
  drawAll();
}

/* ---------- 基本型 ---------- */
static class Tri {
  int i, j; boolean up;                 // up=true: 上向き△, false: 下向き▽
  Tri(int i,int j,boolean up){ this.i=i; this.j=j; this.up=up; }
  public boolean equals(Object o){
    if(!(o instanceof Tri)) return false;
    Tri t=(Tri)o; return i==t.i && j==t.j && up==t.up;
  }
  public int hashCode(){ return Objects.hash(i,j,up); }
}

/* ---------- 列挙 ---------- */
void enumerate(){
  results.clear(); seenKeys.clear();
  HashSet<Tri> start = new HashSet<Tri>();
  start.add(new Tri(0,0,true));
  grow(start);
}

void grow(HashSet<Tri> shape){
  if(shape.size()==N){
    // canonical キーで重複除去
    String key = canonicalKey(shape);
    if(!seenKeys.contains(key)){
      seenKeys.add(key);
      results.add(shape);
    }
    return;
  }
  for(Tri t : shape){
    for(Tri nb : neighbors(t)){
      if(!shape.contains(nb)){
        HashSet<Tri> next = new HashSet<Tri>(shape);
        next.add(nb);
        grow(next);
      }
    }
  }
}

// 辺共有の3近傍（“菱形セル (i,j) を上下2分割”のイメージ）
ArrayList<Tri> neighbors(Tri t){
  ArrayList<Tri> out = new ArrayList<Tri>(3);
  if(t.up){
    // 上向き△は：同じ菱形の下▽、左の下▽、左下の下▽
    out.add(new Tri(t.i,   t.j,   false));
    out.add(new Tri(t.i-1, t.j,   false));
    out.add(new Tri(t.i,   t.j-1, false));
  }else{
    // 下向き▽は：同じ菱形の上△、右の上△、右上の上△
    out.add(new Tri(t.i,   t.j,   true));
    out.add(new Tri(t.i+1, t.j,   true));
    out.add(new Tri(t.i,   t.j+1, true));
  }
  return out;
}

/* ---------- 回転・反射（整数格子で安定） ---------- */
// 斜交格子の頂点座標を (x,y) で表す
static class I2 { int x,y; I2(int x,int y){this.x=x;this.y=y;} }

// 60°回転: (x,y) -> (-y, x+y)
I2 rot60(I2 p){ return new I2(-p.y, p.x + p.y); }
// 鏡像（y軸反転に相当）: (x,y) -> (-x - y, y)
I2 reflect(I2 p){ return new I2(-p.x - p.y, p.y); }

// Tri -> 3頂点
ArrayList<I2> triVerts(Tri t){
  ArrayList<I2> vs = new ArrayList<I2>(3);
  if(t.up){
    vs.add(new I2(t.i,   t.j));
    vs.add(new I2(t.i+1, t.j));
    vs.add(new I2(t.i,   t.j+1));
  }else{
    vs.add(new I2(t.i+1, t.j+1));
    vs.add(new I2(t.i+1, t.j));
    vs.add(new I2(t.i,   t.j+1));
  }
  return vs;
}

// 3頂点 -> Tri（最小 (x,y) を持つ頂点があれば上向き）
Tri triFromVerts(ArrayList<I2> v3){
  int u = min(min(v3.get(0).x, v3.get(1).x), v3.get(2).x);
  int v = min(min(v3.get(0).y, v3.get(1).y), v3.get(2).y);
  boolean hasUV=false; for(I2 p:v3) if(p.x==u && p.y==v){ hasUV=true; break; }
  return new Tri(u, v, hasUV);
}

Tri rotateK(Tri t, int k){
  ArrayList<I2> vs = triVerts(t);
  for(int r=0;r<k;r++) for(int i=0;i<3;i++) vs.set(i, rot60(vs.get(i)));
  return triFromVerts(vs);
}

Tri reflectTri(Tri t){
  ArrayList<I2> vs = triVerts(t);
  for(int i=0;i<3;i++) vs.set(i, reflect(vs.get(i)));
  return triFromVerts(vs);
}

HashSet<Tri> transform(HashSet<Tri> shape, int rotK, boolean doReflect){
  HashSet<Tri> out = new HashSet<Tri>();
  for(Tri t: shape){
    Tri q = doReflect ? reflectTri(t) : t;
    q = rotateK(q, rotK);
    out.add(q);
  }
  return out;
}

/* ---------- 正規化＆キー（回転＋鏡像の中で最小を採用） ---------- */
HashSet<Tri> normalize(HashSet<Tri> shape){
  int mi=Integer.MAX_VALUE, mj=Integer.MAX_VALUE;
  for(Tri t: shape){ if(t.i<mi) mi=t.i; if(t.j<mj) mj=t.j; }
  HashSet<Tri> out = new HashSet<Tri>();
  for(Tri t: shape) out.add(new Tri(t.i-mi, t.j-mj, t.up));
  return out;
}

String shapeKey(HashSet<Tri> shape){
  ArrayList<String> list = new ArrayList<String>();
  for(Tri t: shape) list.add(t.i + "," + t.j + "," + (t.up?1:0));
  Collections.sort(list);
  return String.join(";", list);
}

String canonicalKey(HashSet<Tri> shape){
  String best = null;
  for(int r=0;r<6;r++){
    // 回転のみ
    String k0 = shapeKey(normalize(transform(shape, r, false)));
    if(best==null || k0.compareTo(best)<0) best=k0;
    if(MIRROR_SAME){
      // 鏡像＋回転
      String k1 = shapeKey(normalize(transform(shape, r, true)));
      if(k1.compareTo(best)<0) best=k1;
    }
  }
  return best;
}

/* ---------- 描画 ---------- */
PVector V(int a,int b,float s){ return new PVector((a + 0.5f*b)*s, (sqrt(3)/2f*b)*s); }
void drawTri(Tri t,float s){
  PVector A,B,C;
  if(t.up){ A=V(t.i,t.j,s); B=V(t.i+1,t.j,s); C=V(t.i,t.j+1,s); }
  else    { A=V(t.i+1,t.j+1,s); B=V(t.i+1,t.j,s); C=V(t.i,t.j+1,s); }
  beginShape(); vertex(A.x,A.y); vertex(B.x,B.y); vertex(C.x,C.y); endShape(CLOSE);
}

class B{ float minx=1e9,miny=1e9,maxx=-1e9,maxy=-1e9;
  void add(PVector v){ minx=min(minx,v.x); miny=min(miny,v.y); maxx=max(maxx,v.x); maxy=max(maxy,v.y); }
  float w(){ return maxx-minx; } float h(){ return maxy-miny; }
}
B boundsOf(HashSet<Tri> s,float side){
  B b=new B();
  for(Tri t: s){
    PVector A,Bv,C;
    if(t.up){ A=V(t.i,t.j,side); Bv=V(t.i+1,t.j,side); C=V(t.i,t.j+1,side); }
    else    { A=V(t.i+1,t.j+1,side); Bv=V(t.i+1,t.j,side); C=V(t.i,t.j+1,side); }
    b.add(A); b.add(Bv); b.add(C);
  }
  return b;
}

void drawAll(){
  float box = 120, gap = 12, side = 20;

  // 画面に収まる最大列数を算出（右端がはみ出ないように）
  int cols = max(1, int((width - gap - box) / (box + gap)) + 1);

  for(int idx=0; idx<results.size(); idx++){
    int cx = idx % cols, cy = idx / cols;
    float x0 = gap + cx * (box + gap);   // 左上（CORNER）
    float y0 = gap + cy * (box + gap);

    // 枠
    rectMode(CORNER);
    stroke(0,60); noFill();
    rect(x0, y0, box, box);

    // 形を描画（既存ロジックそのまま）
    HashSet<Tri> norm = normalize(results.get(idx));
    B b = boundsOf(norm, side);
    float m = 10;
    float s = min((box - 2*m)/max(1e-6, b.w()),
                  (box - 2*m)/max(1e-6, b.h()));

    pushMatrix();
    translate(x0 + box/2, y0 + box/2);
    scale(s);
    stroke(0); strokeWeight(1.2/s); noFill();
    translate(-(b.minx+b.maxx)/2, -(b.miny+b.maxy)/2);
    for(Tri t: norm) drawTri(t, side);
    popMatrix();
  }

  // 画面下にカウントを表示（確認用）
  fill(0); noStroke(); textAlign(LEFT, BOTTOM);
  text("shown: " + results.size(), 8, height - 8);
}

参考サイト

様々なタイルについて、種類や充填についてwiki形式でまとめられている。画像あり。

Tiling a Triangle with a Polyiamond