Triangle Judgement

Problem

Table: Triangle

+-------------+------+
| Column Name | Type |
+-------------+------+
| x           | int  |
| y           | int  |
| z           | int  |
+-------------+------+
In SQL, (x, y, z) is the primary key column for this table.
Each row of this table contains the lengths of three line segments.

Report for every three line segments whether they can form a triangle.

Return the result table in any order.

Example

Output

Try it YourSelf

Solution

To assess the validity of triangles defined by sets of three values (x, y, z), the approach involves employing a SQL query on the 'Triangle' table. The query utilizes a CASE statement to evaluate the conditions of the triangle inequality theorem, determining whether the sum of any two sides is greater than the length of the third side. The result will be a clear classification of each set as either forming a valid ('Yes') or invalid ('No') triangle, providing a straightforward analysis of the geometric properties within the 'Triangle' dataset."

SELECT x,
       y,
       z,
       CASE
         WHEN x + y > z
              AND y + z > x
              AND x + z > y THEN 'Yes'
         ELSE 'No'
       end triangle
FROM Triangle 

Let's break down the SQL query step by step.

Step 1: SELECT Statement

This query selects columns x, y, and z from the triangle table and adds a new column named triangle. The CASE statement checks whether the given set of values (x, y, z) satisfies the conditions for forming a triangle.

Step 2: Evaluate the CASE statement

The conditions within the WHEN clause check whether the sum of any two sides is greater than the third side. The conditions are:

CASE
   WHEN x + y > z
       AND y + z > x
       AND x + z > y THEN 'Yes'
   ELSE 'No'

• x + y > z: The sum of side x and side y is greater than side z.
• y + z > x: The sum of side y and side z is greater than side x.
• x + z > y: The sum of side x and side z is greater than side y.

If all three conditions are true, then the CASE statement evaluates to 'Yes,' indicating that the given values can form a valid triangle.

If any of the conditions is false, the ELSE clause is triggered, and the CASE statement evaluates to 'No,' indicating that the values cannot form a valid triangle.

Final Output:

+----+----+----+----------+
| x  | y  | z  | triangle |
+----+----+----+----------+
| 13 | 15 | 30 | No       |
| 10 | 20 | 15 | Yes      |
+----+----+----+----------+

Pattern: row-local CASE predicate (derived label column)

Name: encode a pure per-row geometric/business rule as a CASE expression that labels each row without grouping or joining.

Rule (strict triangle inequality): three lengths form a non-degenerate triangle iff each pair sum is strictly greater than the third: x+y>z AND y+z>x AND x+z>y.

Strict vs non-strict: using >= would accept zero-area "triangles." The problem's sample and standard geometry interview expect strict >.

NULL sides: any NULL in x/y/z makes comparisons UNKNOWN → CASE falls to ELSE 'No' (safe default). Overflow: very large INT sides can overflow on x+y in some engines; use BIGINT or compare carefully (x > z - y with care about signs).

When-NOT: do not GROUP BY — each triple is independent. Do not use joins to a geometry table; the predicate is closed-form.

Drill: Label rows as 'Degenerate' when equality holds on one limb and the other two strict inequalities hold. Write the CASE.

🎯 STRICT STANDOUT: Why / mental model / when-not / worked / failure / hostile panel — Triangle Judgement

Why this concept exists (judgment layer)

Pattern: row-local CASE encoding a closed-form predicate. Geometry interviews and SQL both test strict triangle inequality and degenerate (zero-area) edges.

Mental model (install this intuition)

Three lengths form a non-degenerate triangle iff each pair sum is strictly greater than the third. CASE labels Yes/No per row — no GROUP BY, no join.

Worked example with numbers or traced steps

(13,15,30): 13+15=28 < 30 → No
(10,20,15): all three inequalities hold → Yes
(5,5,10): 5+5=10 not > 10 → No (degenerate line)
Pattern name: derived label column via CASE
NULL side → comparisons UNKNOWN → ELSE 'No'

When NOT to use / named alternative

Do not GROUP BY sides. Do not use >= if problem wants positive area. Do not solve with self-joins — predicate is local. Overflow: use wider types if sums may exceed INT.

Failure mode & ops fingerprint

Fingerprint: accepting collinear points with >=; wrong sample when only one inequality checked; silent NULL labeled Yes if CASE order wrong.

Hostile-panel drills (defend the decision)

Q1. Strict vs non-strict inequality?
Model answer: Strict > rejects zero-area; >= accepts degenerate 'triangles.' Problem sample needs strict.

Q2. Pattern name?
Model answer: Row-local CASE predicate / derived classification column — pure per-row rule.

Q3. How to label Degenerate separately?
Model answer: WHEN all three >= and at least one equality THEN 'Degenerate' WHEN all > THEN 'Yes' ELSE 'No'.