当矩形的角被切掉时，得到尽可能最大的矩形

Question

所以我们有一个矩形，假设尺寸为 120 英尺长、72 英尺宽和 20 毫米厚（我们假设厚度可以忽略不计，因此将此长方体视为 2D 矩形）。我想用 JavaScript 来做一个函数，这样如果从这个矩形的角上切掉任何矩形区域，我仍然可以找到尽可能大的块。

这是我的方法，但它是错误的

class Rectangle {
        length: number;
        breadth: number;
        thickness: number;
        area: number;

        constructor(length: number, breadth: number, thickness: number) {
            this.length = length;
            this.breadth = breadth;
            this.thickness = thickness;
            this.area = length * breadth;
        }
    }

    const calculateUsableDimensions = (
        deductions: IDefectWidgetContent['deductions'],
        defaultDimensions: IDefectWidgetContent['defaultDimensions']
    ): Rectangle => {
        const { length: defaultLength, breadth: defaultBreadth, thickness } = defaultDimensions;

        deductions.sort(
            (a, b) => Number(b.length) * Number(b.breadth) - Number(a.length) * Number(a.breadth)
        );

        let lengthSide = 0;
        let breadthSide = 0;

        for (const deduction of deductions) {
            const { corner, length: deductionLength, breadth: deductionBreadth, thickness } = deduction;

            if (corner === 'A' || corner === 'B') {
                lengthSide += Number(deductionLength);
            } else {
                breadthSide += Number(deductionBreadth);
            }
        }

        const remainingLength = Number(defaultLength) - lengthSide;
        const remainingBreadth = Number(defaultBreadth) - breadthSide;

        return new Rectangle(remainingLength, remainingBreadth, 20); // Thickness is set to 20
    };

这里是这个的游乐场 游乐场| StoneTEKK 缺陷可视化工具

这就是维度和扣除数据的样子

deductions: [
               { corner: 'A', length: 'l', breadth: 'b', thickness: '20' },
               { corner: 'B', length: 'l', breadth: 'b', thickness: '20' },
               { corner: 'C', length: 'l', breadth: 'b', thickness: '20' },
               { corner: 'D', length: 'l', breadth: 'b', thickness: '20' }
            ],
defaultDimensions: { length: '120', breadth: '72', thickness: '20' },

假设所有数据类型均为 int/Number。可视化工具还可以准确地表示切口。只是它不能正确计算切口，并且无法以能够处理重叠的方式减去扣除额，并生成可用的最大矩形。

Answer 1

我看，有4位候选人。对于减去其角的每条边，即中间部分，直接滑到另一侧，直到撞到墙上。

对所有边缘进行此操作并找到最大的区域。

如果矩形有角度怎么办？我仍在努力证明。我可能错了。

function findBiggestRectangle(defaultDimensions, deductions) {
  const { length, breadth, thickness } = defaultDimensions;

  // for quick reference
  const corners = deductions.reduce(function(agg, item) {
    agg[item.corner] = item
    return agg
  }, {})

  let maxArea = 0;
  let maxRectangle;

  // start from top edge
  var edge = length - corners['D'].length - corners['C'].length
  var vert1 = breadth - (corners['D'].length < corners['A'].length ? corners['A'].breadth : 0)
  var vert2 = breadth - (corners['C'].length < corners['B'].length ? corners['B'].breadth : 0)
  var vert = Math.min(vert1, vert2)
  var area = vert * edge
  if (area > maxArea) {
    maxArea = area
    maxRectangle = {
      area: area,
      length: edge,
      breadth: vert,
      start: "top",
    }
  }  
  
  // start from bottom edge
  var edge = length - corners['A'].length - corners['B'].length
  var vert1 = breadth - (corners['A'].length < corners['D'].length ? corners['D'].breadth : 0)
  var vert2 = breadth - (corners['B'].length < corners['C'].length ? corners['C'].breadth : 0)
  var vert = Math.min(vert1, vert2)
  var area = vert * edge
  if (area > maxArea) {
    maxArea = area
    maxRectangle = {
      area: area,
      length: edge,
      breadth: vert,
      start: "bottom",
    }
  }  
  
  // start from left edge
  var edge = breadth - corners['D'].breadth - corners['A'].breadth
  var vert1 = length - (corners['D'].breadth < corners['C'].breadth ? corners['C'].length : 0)
  var vert2 = length - (corners['A'].breadth < corners['B'].breadth ? corners['B'].length : 0)
  var vert = Math.min(vert1, vert2)
  var area = vert * edge
  if (area > maxArea) {
    maxArea = area
    maxRectangle = {
      area: area,
      length: vert,
      breadth: edge,
      start: "left",
    }
  }  
    
  // start from right edge
  var edge = breadth - corners['C'].breadth - corners['B'].breadth
  var vert1 = length - (corners['C'].breadth < corners['D'].breadth ? corners['D'].length : 0)
  var vert2 = length - (corners['B'].breadth < corners['A'].breadth ? corners['A'].length : 0)
  var vert = Math.min(vert1, vert2)
  var area = vert * edge
  if (area > maxArea) {
    maxArea = area
    maxRectangle = {
      area: area,
      length: vert,
      breadth: edge,
      start: "right",
    }
  }  
      
  return maxRectangle
}



// Test data
const defaultDimensions = { length: '120', breadth: '72', thickness: '20' }
const deductions = [
  { corner: 'A', length: '30', breadth: '20', thickness: '20'},
  { corner: 'B', length: '40', breadth: '10', thickness: '20'},
  { corner: 'C', length: '20', breadth: '30', thickness: '20'},
  { corner: 'D', length: '30', breadth: '30', thickness: '20'}
]

console.log (findBiggestRectangle(defaultDimensions, deductions))

<!--
|---|
|D C|
|A B|
|---|
-->