Claude Fable 5 vs. GPT 5.6 Sol - 包括的なレビュー

最近の GPT 5.6シリーズがリリースされ、様々なランキングでFable 5と激しい競争を繰り広げている。どちらが強いのか、誰もが知りたがっている。

私も知りたいです。ランキングを見るだけでなく、実際にランキングを参考にして、どちらがより優れたパフォーマンスを発揮するか、いくつかのテストケースで検証してみましょう。

ケース1：単一ファイル形式のウェブページ

プロンプトワード：

「コンテンツスケジュールダッシュボード」を作成し、すぐに使用できる単一のindex.htmlファイルを配信します。

このページには、タイトル、担当者、プラットフォーム、公開日、ステータスの各項目を含む12個のサンプルエントリが含まれています。以下の内容を実装する必要があります。

1. 担当者、プラットフォーム、ステータスで絞り込み検索。
2. 2. タイトルを検索する。
3. 3. カードを「下書き」、「レビュー待ち」、「公開済み」の3つの列の間でドラッグします。
4. 4. 変更された結果はlocalStorageに書き込まれ、更新後も保持されます。
5. 5. 直近のステータス変更を元に戻す機能をサポートする。
6. 6. デスクトップ端末とモバイル端末の両方で正常に動作します。
7. 7. 外部ライブラリ、フォント、画像、またはオンラインリソースを参照しないでください。

完了後、ローカルサービスを開始し、コンソールエラー、フィルタリング、ドラッグ、更新と復元、モバイルレイアウトを確認します。見つかった問題をすべて修正し、実行コマンドと機能の説明を提供します。ファイルを作成して直接実行してください。解決策の説明だけで終わらせないでください。

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5の強みはその軽量性にある。コア機能はわずか15KB、441行のコードで実装されている。しかし、最大の問題点は製品全体の使い勝手にある。ページレイアウトがデフォルトのバックエンドスタイルに酷似しているため、視覚的な統一感に欠けるのだ。

GPT Sol 5.6は、より成熟したページ階層と完全なビジュアルシステムを備えており、まるで社内開発製品のように仕上がっています。しかし、容量はなんと36KB、コード行数は1265行にも及び、Fable版の約2倍の複雑さとなっています。

しかし、最終製品の品質は依然として非常に重要であり、コードを数行追加することは問題ではないと思うので、このケースでは... GPT 5.6 ソルが勝利。

ケース2：複数の制約条件を考慮したスケジューリング

プロンプトワード面接は8名の候補者を対象に実施されます。面接可能な時間は9:00、10:00、11:00、14:00、15:00、16:00で、各回50分、セッション間に10分間の休憩があります。会社には会議室が2つあり、1号室と2号室です。

制限事項は以下のとおりです。

• AとBは同じ面接官によって面接を受ける必要があり、面接時間は重複してはならない。
• – オプションBは午後のみ予約可能です。
• – Cは午前中のみ予約可能です。
• – DはAより後でなければならない。
• – Eは会議室2号室のみ使用可能です。
• – Fは10:00または15:00には予約できません。
• – GとHは同じ会議室で連続して実施する必要があり、GはHより先に実施しなければならない。
• – Hは15:00までに終了しなければなりません。 – 12:00から14:00の間は面接は予定されません。
• 各候補者は一度しか立候補できません。

最終的なスケジュールを提示してください。次に、すべての制限事項を項目ごとに確認し、利用可能な時間帯を示してください。競合が見つかった場合は、それに応じて調整してください。制限事項を削除したり、緩和したりしないでください。

GPT 5.6 Sol：

Claude Fable 5：

Claude 寓話5の答えは正しく、彼は各点を注意深く確認した。問題はFの配置にあった。11時の時点で会議室1は空いていたが、Fの面接は16時に予定されており、面接時間が2時間延長されることになったのだ。

GPT 5.6 解答では、Fの面接を午前11時に、Aの面接と同時に会議室2で行うことを推奨しています。問題文には、2人の面接官が同じ面接官であるとは明記されていないため、この取り決めは有効です。

このケース GPT 5.6 ソルが勝利。

ケース3　サプライヤー決定

プロンプトワード：

同社は、ソフトウェアを購入するか、社内で開発するか、プロジェクトを延期するかを決定する必要がある。考慮されるのは、今後12か月間の資金への影響のみである。

与えられた条件：

従業員一人当たりの月額総費用は38,000元です。

プロジェクトが稼働開始すると、従業員4人分の業務量を削減でき、削減効果はプロジェクト稼働開始後の最初の満月から計算されます。

選択肢A：

- 年間ソフトウェア料金は180万元で、契約締結時に全額支払う必要があります。

– 実施費用：30万元

導入には2ヶ月かかります。

成功率85％。

導入が失敗した場合、返金は一切行われず、人件費の削減も実現しません。

選択肢B：

―6人のエンジニアが5ヶ月かけて製品を開発し、それぞれ月額4万5000元を受け取った。

予定通りに完了する確率は65%です。

延長期間中の平均利用時間は3ヶ月長くなり、延長期間中も6名が引き続き利用を継続しています。

―運用開始後、保守管理のために2名の技術者が雇用され、それぞれ月額4万5000元が支払われる。

予定通りに開始されるか、遅れるかにかかわらず、プロジェクトはいずれ開始されるだろう。

オプションC：

12ヶ月の遅延は、人件費の追加費用や節約にはつながらない。

3つの方式それぞれについて、結果を個別に計算してください。

1. 予定通りまたは成功裏に完了した場合の純現金収支への影響。

2. 失敗または遅延が発生した場合の純現金への影響。

3. 確率に基づいて算出された予想純現金影響額。

4．結論に影響を与える3つの主な前提条件。

明確な提言を盛り込んだ決定メモを600語以内で作成してください。すべての計算は検証可能でなければならず、金額はすべて1万元単位で表記してください。

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5の分析はより包括的です。3つの前提すべてが意思決定のリスクに対処していますが、...Claude 寓話5では、Bが2、3年でAを追い抜くと述べているが、最後には24ヶ月以上待つならAに切り替えるべきだと示唆している。この2つの結論は互いに矛盾している。

GPT 5.6 ソルの回答は簡潔で、計算過程も完全であり、結論は問題で示された12ヶ月の範囲を超えていませんでした。3つの選択肢の状態、確率、および現金収支はすべて正しく計算されていました。最終的にCが選択され、オンラインで確認する必要があった場合はAが選択されましたが、これは数値と完全に一致していました。

このケース GPT 5.6 ソルが勝利。

ケース4：データのオンライン検証

プロンプトワード：

今日現在、比較 GPT-5.6 Sol、Claude Fable 5は、Googleの現在の機能に最も近い、主力APIモデルと言えるでしょう。

引用元は、3つの企業ウェブサイト、開発者向けドキュメント、ヘルプセンター、およびシステムカードのみを使用してください。メディア、ブログ、情報集約サイト、検索結果の要約は引用しないでください。

以下の情報をご確認ください。

– APIモデルID

－投入価格と産出価格。

– コンテキストウィンドウ;

-最大出力長

– サポートされている入力タイプ。

– 推論強度設定;

―ツールへのアクセスおよびコンピュータ操作のサポート。

– データ保持要件

– 現在の空き地；

公式に公開されたコード、専門的な作業、およびツールの使用評価。

各情報には、該当ページへの直接リンクとアクセス日を記載してください。複数の公式ページで情報が食い違っている場合は、食い違う情報を列挙し、どちらの情報を採用すべきかを明記してください。公式ウェブサイトに明記されていない情報については、「公式ウェブサイトには記載されていません」と記載してください。

最後に、リポジトリのコード変更、長文PDFの監査、オンライン調査のためのモデル選択機能が提供されます。公式の事実と個人的な判断は区別されます。

Claude Fable 5：

Claude Fable 5にはちょっとした問題があります…GPT-5.6という推論設定は誤りです。最小値の設定はありません。

しかし GPT-5.6 ソル比較モデルが選択されましたGemini 3.5 Flashでは、このエラーは少し大きくなります。

このケース Claude Fableが5勝。

事例5：執筆における制約

プロンプトワード：

以下の製品情報に基づいて、800～1000語の中国語版WeChat公式アカウント記事を作成してください。

製品情報：

– 製品名：StoneNote

– バージョン: 2.3;

– 発売日：2026年7月10日

WindowsおよびmacOSに対応しています。

– メモはローカルのMarkdownファイルとして保存されます。

双方向リンクを追加しました。

– スクリーンショットのOCR機能を追加しました。

– 無料ユーザーは1ヶ月あたり500枚のスクリーンショットを認識できます。

– プロ版：月額29元

– OCRにはインターネット接続が必要です。

– 通常のメモ編集はオフラインでも使用できます。

現在、Linuxはサポートされていません。

既存ユーザーは、アップグレード後にノートを移行する必要はありません。

モバイルアプリの正式なリリース日はまだ発表されていません。

執筆要件：

ユーザー体験、ユーザーレビュー、またはパフォーマンスデータを捏造しないこと。

– 上記の14の事実をすべて保持する。

– 「エンパワーメント、エコシステム、クローズドループ、ブロックバスター、ディスラプション、再定義」といった用語を使用せずに。

– 「XではなくYです」という表現は避けてください。

– まず、バージョンアップについて述べてください。

本文では箇条書きを使用しないでください。

– これは、このサービスがどのようなユーザーに適しているかを説明するとともに、現在の制限事項についても概説しています。

– 見出しは5つまで設定可能で、見出しには感嘆符を使用できません。

この記事には事実確認チェックリストが含まれており、14項目の情報それぞれについて、記事に含まれているかどうかをマークし、対応する文章を引用している。

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 すべての製品情報が含まれており、タイトルに記載されている情報と資料に記載されていない情報を区別できますが、本文は製品マニュアルのようで、WeChat公式アカウントの雰囲気に欠けています。

Claude Fable 5はより完成度の高い見た目になっている。見出し2、4、5はすべてより優れている... GPT タイトルは適切だが、内容がやや行き過ぎている。制限を超えた場合や、より多くのデータが必要な場合は、Pro版に加入できると書かれている。しかし、Pro版の料金は月額29元であるということしか分かっていない。

この事例は、純粋な文体に基づいて分類されています。Claude Fableが5勝。複数の制約と架空の禁止事項に基づいて順位付け。GPTソルが-5.6のスコアで勝利した。

ケース6 3D太陽系

プロンプトワード：

直接実行できる単一ファイルのウェブページを作成します。 Three.js 暗い色の展示ホールに、機械式の太陽系観測機器が展示されている。

必要とする：

1. 太陽、地球、月は正しい親子関係を形成しており、地球は太陽の周りを公転し、月は同時に地球の周りを公転している。

2. 機械構造を表すには、歯車、金属製ブラケット、トラックリングを使用してください。単に球体をいくつか使用するだけではいけません。

3. ドラッグによるビューの回転、スクロールによるズーム、一時停止/再開、速度調整、ビューのリセットをサポートします。

4. 地球または月をクリックすると、カメラは対応する天体にスムーズに移動し、その名前、周期、および現在の位置を表示します。

5. 純粋な黒の背景に構造物が隠れてしまわないように、柔らかな影、金属的な質感、環境光、局所的なハイライトを追加します。

6. ページサイズを変更しても画面が伸びず、モバイルデバイスでも操作できます。

7. ユーザーが「モーション効果を軽減」を有効にすると、デフォルトでは一時停止状態になります。自動回転させる。

8. 画像、モデル、音声素材は一切使用していません。すべての構造はコードによって生成されます。

9. 最終成果物は、開いて実行できる単一のHTMLファイルです。

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 ソルの実際の画像は、より完成度の高い機械展示に近いもので、物体の比率や素材の違いがより明確です。対照的に、フェイブルの歯車や土台は、簡略化された模型のように見えます。

Claude Fable 5の利点は、コードが短く、構造が分かりやすい点にある。月の満ち欠けと地球の周期の表現は、実際の周期のスケールに合わせて調整されており、これは以前のバージョンからの大きな改善点である。 GPT 厳格な。

しかし総合的に見ると、勝者はやはり… GPT‑5.6 Sol。

事例7：未来都市

プロンプトワード：

Three.jsを使用して、未来都市のための単一ファイル形式のプログラムによるウェブページを作成します。

都市には、高さの異なる建物が少なくとも300棟、道路、街灯、飛行車両、遠景の霧効果などが含まれている必要があります。建物はInstancedMeshなどのバッチレンダリング方式で生成する必要があり、各建物ごとに多数のオブジェクトを個別に作成することはできません。

ページには以下の情報を提供する必要があります。

照明や建物の窓は、昼間、夕暮れ、夜間の環境変化に合わせて同期して変化する。

– 自由観察と自動クルーズ用の2つのカメラモード

建物をクリックすると、その建物がハイライト表示され、ランダムに生成された数字、高さ、用途が表示されます。

建物の密度、車両数、巡航速度の調整

- 現在のFPSと表示されているシーンオブジェクトの数

– ワンクリック都市を再生するには、同じ乱数シードを用いて同じレイアウトを生成する必要がある。

ウィンドウのスケーリング、モバイル端末のタッチ入力、リソースの解放、および繰り返し生成後のメモリの問題を処理します。最終成果物は、直接実行可能なHTMLファイルです。

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 Sol 建物はカスタムシェーダーを使用して窓を生成します。水平な屋根は...自動窓をなくすことで、ありふれたテクスチャが屋上まで容易に広がってしまうという問題が解決される。

Claude 『Fable 5』は非常に洗練されており、わずか478行のコードしか使用されていません。建物、道路、街灯、乗り物はすべてバッチ処理でレンダリングされています。青と温かみのある黄色の窓とシアン色の飛行乗り物のコントラストが強く、一見するとより伝統的な「未来都市」の雰囲気を醸し出しています。

しかし全体的に見て、Claude 結局、Fableが5勝する。だって、将来、屋上に窓があってはいけないなんて誰も言っていないんだから。

ケース8：製品分解アニメーション

プロンプトワード：

架空のポータブルコーヒーメーカーをテーマにした、単一ファイルの製品紹介ページを作成してください。

ページの左側にはテキストセクションがあり、右側にはThree.jsの製品モデルが表示されます。製品モデルは外部の3Dファイルを参照することはできません。基本的な幾何学的形状を使用して構築する必要があります。

スクロールダウンすると、以下の手順が順番に実行されます。

1. コーヒーマシンが暗闇の中から画面に回転して現れる。

2. 外装ケース、フィルターカップ、水タンク、バッテリーモジュールはスムーズに分離できます。

3. 水の流れは、パーティクルアニメーションまたは曲線アニメーションを使用して表示されます。

4. すべての部品が再組み立てされ、レンズが製品前面に戻されます。

スクロールが反転する場合、アニメーションも正確に反転する必要があります。直接再生は許可されません。チャプターの位置、現在の進行状況、キーボード入力、モバイルレイアウトを含めてください。システムが動的効果を減らすように設定されている場合は、連続アニメーションの代わりに静的な分解図を使用してください。

足場の使用は禁止されています。最終納品物はHTMLファイルである必要があります。

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 Solモデルは、携帯型コーヒーマシンというコンセプトにより近い製品です。Claude Fable 5は、固定された台座、支柱、コーヒーカップを備えており、卓上コーヒーメーカーに似ている。

Claude Fable 5はアニメーションの状態設計に優れており、わずか406行程度で構造が明確です。最終的な効果という点では、このケースは依然として… GPT-5.6ソルの方がわずかに良い。

事例9：倉庫番ゲーム

プロンプトワード：

単一ファイルで構成されたWebベースの倉庫番ゲームを作成します。グラフィックはCanvasまたはDOMのどちらを使用しても作成可能です。

必要とする：

1. 難易度が上がる8つのレベルが含まれており、すべて解けることが保証されています。

2. キーボード、画面上の矢印キー、スワイプジェスチャーに対応しています。

3. 無制限の元に戻す、やり直し、再開、およびレベル選択をサポートします。

4. 各レベルの歩数、押す回数、完了時間、最高スコアを記録します。

5. ページを更新すると、ロック解除済みのレベルと最高スコアが保持されます。

6. ボックスは壁を通り抜けたり、重なったり、引っ張られたりすることはできません。キャラクターはマップから出ることはできません。

7. プレイヤーがレベルをクリアすると短いアニメーションが再生されますが、プレイヤーがゲームを続けることを妨げるものではありません。

8. このページには操作方法の説明が必要であり、携帯電話では縦向きと横向きの両方で正しく表示される必要があります。

9. 外部画像やゲームアセットは使用しないでください。最終製品にはHTMLファイル1つだけを納品してください。

各レベルをクリアするためのルートが少なくとも1つ存在することを確認してください。

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 Solは、視覚的な完成度が格段に高い。ページには明確なタイトルエリア、レベルサイドバー、データパネル、チェス盤、操作エリア、ステータスフィードバックが備わっている。壁、箱、ターゲットポイント、倉庫内の箱など、すべてが非常に分かりやすい。既に公開可能なミニゲームのように見える。

Claude Fable 5の最大の利点はそのコンパクトさで、コードは約14KBしかありません。基本的なルール、キーボード操作、矢印キー、スワイプ、セーブ、パーティクルアニメーションなどが実装されています。しかし、レベルの難易度が単純すぎるのが難点です。

GPT-5.6 Solはレベルの深さ、ビジュアル、状態の信頼性、詳細なフィードバックにおいて優れているため、勝者は... GPT‑5.6 Sol。

ケース10のスプレッドシート

プロンプトワード：

ユーザーインターフェースを必要とせず、TypeScriptを使用してミニスプレッドシートの数式エンジンをゼロから実装します。

必要なサポート:

– 数値、括弧、および +、-、*、/ による演算

セル参照はA1、B2の形式で表す。

– A1:B5の領域

– SUM、AVERAGE、MIN、MAX、IF関数

– 文字列比較（>、<、>=、<=、=）

- セル依存の更新は、影響を受けるセルのみを再計算します。

循環参照を検出し、読みやすい循環パスを返します。

- 空のセル、ゼロ除算、不明な関数、不正な数式のエラー

– 数式の先頭にある等号と大文字小文字を区別しない関数名

eval、関数コンストラクタ、またはサードパーティの数式解析ライブラリは使用しないでください。明確なディレクトリ構造、コア実装、および...を提供してください。自動テストでは、少なくとも以下の項目を網羅する必要があります。計算の優先順位、ネストされた関数、ロケールの計算、依存関係の伝播、および循環参照。

GPT‑5.6 Sol：

コード：

import { expandRange, normalizeAddress } from "./address";

import { asSpreadsheetError, FormulaError } from "./errors";

import { evaluateExpression } from "./evaluator";

import { parseFormula } from "./parser";

import type { CellValue, Expression, FormulaResult, SpreadsheetError } from "./types";

export type CellInput = number | string | boolean | null;

interface Cell {

input: CellInput;

expression?: Expression;

parseError?: SpreadsheetError;

dependencies: Set;

result: FormulaResult;

}

const EMPTY_RESULT: FormulaResult = { ok: true, value: null };

function collectDependencies(expression: Expression, output = new Set()): Set {

switch (expression.kind) {

case "cell":

output.add(expression.address);

break;

case "range":

for (const address of expandRange(expression.start, expression.end)) output.add(address);

break;

case "unary":

collectDependencies(expression.operand, output);

break;

case "binary":

collectDependencies(expression.left, output);

collectDependencies(expression.right, output);

break;

case "call":

for (const argument of expression.args) collectDependencies(argument, output);

break;

}

return output;

}

export class Spreadsheet {

private readonly cells = new Map();

private readonly dependents = new Map>();

private lastRecalculated: string[] = [];

setCell(address: string, input: CellInput): FormulaResult {

const normalized = normalizeAddress(address);

const previous = this.cells.get(normalized);

if (previous) this.removeReverseEdges(normalized, previous.dependencies);

const cell = this.createCell(input);

this.cells.set(normalized, cell);

this.addReverseEdges(normalized, cell.dependencies);

this.recalculate(normalized);

return this.getCell(normalized);

}

clearCell(address: string): FormulaResult {

return this.setCell(address, null);

}

getCell(address: string): FormulaResult {

const normalized = normalizeAddress(address);

return this.cells.get(normalized)?.result ?? EMPTY_RESULT;

}

getValue(address: string): CellValue {

const result = this.getCell(address);

if (!result.ok) throw new FormulaError(result.error.code, result.error.message, result.error);

return result.value;

}

getLastRecalculatedCells(): string[] {

return […this.lastRecalculated];

}

private createCell(input: CellInput): Cell {

if (typeof input !== "string" || !input.startsWith("=")) {

return { input, dependencies: new Set(), result: { ok: true, value: input } };

}

try {

const expression = parseFormula(input);

return { input, expression, dependencies: collectDependencies(expression), result: EMPTY_RESULT };

} catch (error) {

const parseError = asSpreadsheetError(error);

return { input, parseError, dependencies: new Set(), result: { ok: false, error: parseError } };

}

}

private addReverseEdges(address: string, dependencies: Set): void {

for (const dependency of dependencies) {

const addresses = this.dependents.get(dependency) ?? new Set();

addresses.add(address);

this.dependents.set(dependency, addresses);

}

}

private removeReverseEdges(address: string, dependencies: Set): void {

for (const dependency of dependencies) {

const addresses = this.dependents.get(dependency);

addresses?.delete(address);

if (addresses?.size === 0) this.dependents.delete(dependency);

}

}

private collectAffected(start: string): Set {

const affected = new Set();

const pending = [start];

while (pending.length > 0) {

const address = pending.pop() as string;

if (affected.has(address)) continue;

affected.add(address);

for (const dependent of this.dependents.get(address) ?? []) pending.push(dependent);

}

return affected;

}

private recalculate(start: string): void {

const dirty = this.collectAffected(start);

const states = new Map();

const stack: string[] = [];

const cycleMembers = new Set();

const recalculated = new Set();

const evaluateCell = (address: string): FormulaResult => {

const cell = this.cells.get(address);

if (!cell) return EMPTY_RESULT;

if (!dirty.has(address)) return cell.result;

if (states.get(address) === "done") return cell.result;

if (states.get(address) === "visiting") {

const startIndex = stack.indexOf(address);

const cycle = […stack.slice(startIndex), address];

const error: SpreadsheetError = {

code: "CIRCULAR_REFERENCE",

message: `Circular reference: ${cycle.join(" -> ")}`,

cycle,

};

for (const member of cycle.slice(0, -1)) {

cycleMembers.add(member);

const memberCell = this.cells.get(member);

if (memberCell) memberCell.result = { ok: false, error };

}

return { ok: false, error };

}

states.set(address, "visiting");

stack.push(address);

for (const dependency of cell.dependencies) evaluateCell(dependency);

stack.pop();

if (!cycleMembers.has(address)) {

if (cell.parseError) {

cell.result = { ok: false, error: cell.parseError };

} else if (!cell.expression) {

cell.result = { ok: true, value: cell.input };

} else {

try {

const value = evaluate => {

const result = evaluateCell(dependency);

if (!result.ok) {

throw new FormulaError(result.error.code, result.error.message, result.error);

}

return result.value;

});

cell.result = { ok: true, value };

} catch (error) {

cell.result = { ok: false, error: asSpreadsheetError(error) };

}

}

}

states.set(address, "done");

recalculated.add(address);

return cell.result;

};

for (const address of dirty) evaluateCell(address);

this.lastRecalculated = […recalculated];

}

}

Claude Fable 5：

コード：

import { parse } from "./parser.js";

import { Node } from "./ast.js";

import { evaluate, extractDeps, Value } from "./evaluator.js";

import { FormulaError, badFormula, cycle } from "./errors.js";

interface Cell {

raw: string;

数式: ノード | null; // 数式でないセルは null です

value: Value;

deps: Set// オリジナル作品は誰に依存しているのでしょうか？

dependents: Set// オリジナルに依存している人は誰ですか？

}

/** 文字と数字のリスト */

function colToNum(col: string): number {

let n = 0;

for (const c of col) n = n * 26 + (c.charCodeAt(0) – 64);

return n;

}

function numToCol(n: number): string {

let s = "";

while (n > 0) { const r = (n – 1) % 26; s = String.fromCharCode(65 + r) + s; n = Math.floor((n – 1) / 26); }

return s;

}

function splitAddr(addr: string): [string, number] {

const m = addr.match(/^([A-Z]+)([0-9]+)$/);

(!m) が新しい Error("不正なアドレス: " + addr); をスローする場合

return [m[1], parseInt(m[2])];

}

export class Sheet {

private cells = new Map();

/** 直近の SET 操作で実際に再計算されたセル (増分再計算のテスト用) */

public lastRecalculated: string[] = [];

private cell(addr: string): Cell {

let c = this.cells.get(addr);

if (!c) {

c = { raw: "", formula: null, value: null, deps: new Set(), dependents: new Set() };

this.cells.set(addr, c);

}

return c;

}

expandRange = (start: string, end: string): string[] => {

const [c1, r1] = splitAddr(start);

const [c2, r2] = splitAddr(end);

const colA = Math.min(colToNum(c1), colToNum(c2)), colB = Math.max(colToNum(c1), colToNum(c2));

const rowA = Math.min(r1, r2), rowB = Math.max(r1, r2);

const out: string[] = [];

for (let col = colA; col <= colB; col++) {

for (let row = rowA; row <= rowB; row++) out.push(numToCol(col) + row);

}

return out;

};

get(addr: string): Value {

return this.cells.get(addr.toUpperCase())?.value ?? null;

}

getError(addr: string): FormulaError | null {

const v = this.get(addr);

return v instanceof FormulaError ? v : null;

}

/** セルの数式を「=」で開始し、残りは数値または文字列とします。 */文字通りの量 */

set(addr: string, raw: string): void {

addr = addr.toUpperCase();

const cell = this.cell(addr);

/* 古い依存関係を削除 */

for (const d of cell.deps) this.cells.get(d)?.dependents.delete(addr);

cell.deps.clear();

cell.raw = raw;

cell.formula = null;

if (raw.startsWith("=")) {

try {

cell.formula = parse(raw.slice(1));

for (const d of extractDeps(cell.formula, { expandRange: this.expandRange })) {

cell.deps.add(d);

this.cell(d).dependents.add(addr);

}

} catch (e) {

cell.value = badFormula((e as Error).message);

this.recalc(addr, /* selfIsError */ true);

return;

}

}

this.recalc(addr);

}

/** ループチェック: deps に沿って addr に戻ることが可能かどうかを確認し、読みやすいパスを返します */

private findCycle(addr: string): string[] | null {

const path: string[] = [];

const visiting = new Set();

const dfs = (cur: string): string[] | null => {

path.push(cur);

visiting.add(cur);

for (const d of this.cells.get(cur)?.deps ?? []) {

if (d === addr) return […path, addr];

if (!visiting.has(d)) {

const found = dfs(d);

if (found) return found;

}

}

path.pop();

visiting.delete(cur);

return null;

};

return dfs(addr);

}

/** 影響を受けるサブグラフ（自己依存関係と推移的依存関係）を収集し、依存関係トポロジーでソートして、これらのサブグラフのみを再計算します。*/

private recalc(changed: string, selfIsError = false): void {

/* 1. 影響を受けるセット */

const affected = new Set([changed]);

const q = [changed];

while (q.length) {

const cur = q.shift()!;

for (const dep of this.cells.get(cur)?.dependents ?? []) {

if (!affected.has(dep)) { affected.add(dep); q.push(dep); }

}

}

/* 2. サイクル検出：影響を受けるセットのうち、どのメンバーがサイクル上にあるか？ */

const cyclic = new Map();

for (const a of affected) {

const c = this.findCycle(a);

if (c) cyclic.set(a, c);

}

/* 3. 影響を受けるサブグラフ内でのトポロジカルソート（依存関係が最初に計算されます）。サイクル上のセルは直接エラーに設定されます */

const order: string[] = [];

const indeg = new Map();

for (const a of affected) {

if (cyclic.has(a)) continue;

let n = 0;

for (const d of this.cells.get(a)?.deps ?? []) {

if (affected.has(d) && !cyclic.has(d)) n++;

}

indeg.set(a, n);

}

const ready = […indeg.entries()].filter(([, n]) => n === 0).map(([a]) => a);

while (ready.length) {

const cur = ready.shift()!;

order.push(cur);

for (const dep of this.cells.get(cur)?.dependents ?? []) {

if (!indeg.has(dep)) continue;

const n = indeg.get(dep)! – 1;

indeg.set(dep, n);

if (n === 0) ready.push(dep);

}

}

/* 4. 評価 */

this.lastRecalculated = [];

for (const [a, path] of cyclic) {

this.cell(a).value = cycle(path);

this.lastRecalculated.push(a);

}

for (const a of order) {

const cell = this.cell(a);

if (a === changed && selfIsError) { this.lastRecalculated.push(a); continue; }

if (cell.formula) {

cell.value = evaluate(cell.formula, { get: (x) => this.get(x), expandRange: this.expandRange });

} else if (a === changed) {

cell.value = parseLiteral(cell.raw);

}

this.lastRecalculated.push(a);

}

}

}

function parseLiteral(raw: string): Value {

if (raw === "") return null;

const n = Number(raw);

if (!Number.isNaN(n) && raw.trim() !== "") return n;

return raw;

}

GPT-5.6 Solには深刻な問題があります。数式がA10やB20のような行番号を持つセルを参照している場合、数式エラーが表示されます。表が10行目に達すると、多くの計算で問題が発生する可能性があります。

Claude Fable 5は100回の計算を正常に完了しました。最初の数値を変更すると、以降のすべての結果も更新されます。

このラウンドでは Claude Fableが5勝。

10件のテスト後、GPT-5.6 ソルは明らかに6つのアイテムを獲得しました。Claude 『Fable 5』は5部門中3部門で受賞し、WeChat公式アカウントの投稿は各部門で1部門ずつ優位に立った。

ウェブページ、3Dアニメーション、ミニゲームを作成する際は、GPTSolのバージョン5.6では、通常より多くのコードが必要になりますが、より完成度の高いページ構造、視覚的な詳細、ユーザーフィードバック、例外処理が提供されます。これは特に倉庫番において顕著で、レベルの難易度が上がり、インターフェースはすぐに遊べるミニゲームに近づいています。

Claude Fable 5では、より短いコードと効率的なワークフローが実現されています。Future Cityアプリケーションでは、建物、道路、街灯、車両、環境、都市再生の一括切り替えを完了するために、わずか478行のコードしか使用していません。ビジュアルもより伝統的なSF都市の雰囲気を持ち、テキストもより自然なものになっています。

10件のケースを実行してみた結果、モデルのランキングはあくまでも範囲を絞り込むための補助的な役割しか果たさないと感じました。真に経験を左右するのは、目の前の課題そのものです。

GPT-5.6 Sol は今回のラウンドでより多くの勝利を収めた。完成度は確かに高く、多くの結果はわずかな修正で使用できる。しかし、コストも明らかだ。コードが長くなり、時には...単純その作業は過重だった。

Fable 5では、より軽量な設計が実現しました。コードは通常より短くなり、テキストもより自然な読み心地になっています。

考える速い閲覧、クリック、デモンストレーションが可能なウェブページや小さなゲームを作成するには、まず試してみると良いでしょう。 GPT-5.6 解答。自然なテキスト、簡潔なコード、データ検証、数式処理を優先する場合は、Fable 5 を最初に配置できます。主要なモデルを決定する前に、本番プロジェクトでいくつかのテストケースを実行してください。

私自身推薦する一方のモデルはデータ処理に使用され、もう一方のモデルはデータ検索に使用される。

どちらのモデルも使う価値はありますが、それぞれ適した用途が異なります。一般ユーザーにとって、現在入手可能な最良のモデルとは、常に望ましい最終製品を生成できるモデルです。

元のリンク:巨人の激突Claude フェイブル5と GPT 5.6 ソル：どちらが優れているか？