精华内容
下载资源
问答
  • 如何确定一个正方形
    2021-02-11 04:29:50

    我有一个尺寸为10x10的正方形,我想把它分成25个更小的正方形,尺寸为2x2,所以最后我将得到一个5x5的正方形阵列。什么我还想做的是找到每个新方块的中心坐标。我写了以下代码作为起点,它给出了x(0)和y(0)坐标的正方形中心的坐标。我尝试过嵌套,但这给了我很高的y值。我知道我需要保持一个变量不变,然后根据它迭代另一个变量。我只是不确定如何将它们联系起来。如果任何人可以帮助或指出一些文件,将有助于找到非对角线元素将不胜感激。提前谢谢。在def Cell_centers():

    dx = 2

    dy = 2 #length of cell side

    N = 5 #number of cells

    Xc = zeros(N) #array creation

    Yc = zeros(N)

    x1=0

    y1=0

    for i in range(N): #for loops to define cell centers

    Xc[i] = dx/2 +x1

    x1+=dx #increments x1 positions by dx

    for j in range(N):

    Yc[j] = dy/2 +y1

    y1+=dy

    centers = np.array((Xc, Yc), dtype=float)

    return(centers)

    例如,如果我们有一个正方形,每边2个,把它分成四个边长为1的正方形,我想要的是这样的东西

    ^{pr2}$

    我不知道这是不是正确的Python所以我来这里学习

    更多相关内容
  • 正方形

    千次阅读 2021-05-18 13:49:03
    如果两个点集对应着现实世界中的同一个场景元素,它们就应该是匹配的。仅凭单个像素就判断两个关键点的相似度显然是不够的,因此要在匹配过程中考虑每个关键点周围的图像块。如果两幅图1056:点和正方形的关系时间限制...

    描述与匹配关键点2021-05-09 15:03:50

    局部模板匹配

    通过特征点匹配,可以将一幅图像的点集和另一幅图像(或一批图像)的点集关联起来。如果两个点集对应着现实世界中的同一个场景元素,它们就应该是匹配的。仅凭单个像素就判断两个关键点的相似度显然是不够的,因此要在匹配过程中考虑每个关键点周围的图像块。如果两幅图

    1056:点和正方形的关系

    时间限制: 1000 ms         内存限制: 65536 KB 提交数: 33106     通过数: 22488

    【题目描述】

    有一个正方形,四个角的坐标(x,y)分别是(1,-1),(1,1),(-1,-1),(-1,1),x是横轴,y是纵轴。写一个程序,判断一个给定的点是否在这个正方形内(包括正方形边界)。如

    点此看题面

    给定平面直角坐标系内四个顶点\(p_i\),对于每个点选择与它横坐标相同或纵坐标相同的一个点\(p'_i\)。

    要求\(p'_i\)是一个四边平行于坐标轴的正方形的四个顶点(不能退化成一点)。

    求\(\max_{i=0}^3dis(p_i,p_i')\)的最小值并构造一组方案。

    数据组数\(\le50\)

    暴枚+初步

    前言

    被迫营业。

    题目

    CF

    洛谷

    题目大意:

    \(t\) 组数据,每组数据输入一个整数 \(n\),表示给定的相同等腰直角三角形的数量。

    询问是否能够用上所有三角形拼出一个无空洞的正方形。

    能做到输出 \(\tt YES\) ,否则输出 \(\tt NO\)。

    \(1\le t\le 10^4;1\le n\le 10^9.\)

    讲解

    样例已经给

    题目:统计全为 1 的正方形子矩阵

    最大正方形(统计全为 1 的正方形子矩阵) 解析可以参考leetcode解析public class Solution{public int countSquares(int[][] matrix){final int height = matrix.length;if (height == 0){return 0;}final int width = matrix[0].length;final int[

    css3图片圆形显示如何使用css样式将正方形图片显示为圆形图片布局

    1、图片实现圆形条件

    2、使用布局技术

    3、CSS圆角实现图片圆形实例

    1、图片实现圆形条件

    原本不是圆形图片,通过CSS样式布局实现成圆形图片,首先图片必须为正方形。

    2、使用布局技术

    使用CSS3 圆角技

    c语言4-21 输出指定边长的正方形

    1、

    #include

    int main(void)

    {

    int i, j, len;

    puts("please input an integer.");

    printf("len = "); scanf("%d", &len);

    for(i = 1; i <= len; i++)

    {

    for(j

    第四次实验报告2021-04-18 17:04:49

    —实验目录

    1.鸡兔同笼算法描述;

    2.确定坐标的算法描述;

    3.if语句的运用(判断是正方形还是长方形);

    4.模拟计算机;

    —实验类容

    1.

    实验难点:该实验在设计C语言模板图的时候不算难,难在设计算法表达式,运用了不同于人思维的算法,要结合计算机思维进行思考。

    4.

    实验难点:在此实验中没有太大

    C++9018:1812——长方形2021-04-12 22:33:30

    题目来自:http://218.5.5.242:9018/JudgeOnline/problem.php?id=1812

    题目描述

    棒棒棒有一根长度为n的棒棒,现在他用Prehistorical Power把这根棒棒折成一个长方形且不能是正方形。他想知道他有多少种折法。

    输入

    输入一行,有一个n,为棒棒长度

    输出

    输出一行,为折法的数量

    221. 最大正方形2021-04-12 02:04:37

    221. 最大正方形

    在一个由 '0' 和 '1' 组成的二维矩阵内,找到只包含 '1' 的最大正方形,并返回其面积。

    示例 1:

    输入:matrix = [["1","0","1","0","0"],["1","0","1","1","1"],[

    小程序获取用户清晰头像的方法2021-04-10 10:35:59

    https://wx.qlogo.cn/mmopen/vi_32/xxxxxxxxxxxxxx/0

    最后一个数值代表正方形头像大小(有0、46、64、96、132数值可选,0代表640*640正方形头像)。开发者可根据需要替换头像大小参数进行下载。

    From: 获取用户头像模糊不清晰

    理想正方形 题解2021-03-31 12:02:02

    先言

    若不是看了题解,我倒还真不认为是单调队列优化 \(DP\) , 关于正解的话,不清楚,但是这道题 \(RMQ\) , 线段树 + \(O_2\) 或者 单调队列优化都可以过,(笔者没有挨个实现)

    description

    在一个 \(n \times m\) 的矩阵中,找出一个 \(k \times k\) 的一个正方形,并使取得的正方形的极值差

    LeetCode 221. 最大正方形2021-03-13 20:35:12

    思路

    方法:动态规划

    思路来源:

    LeetCode官方题解 - 最大正方形

    理解 三者取最小+1

    1 class Solution {

    2 public:

    3 int maximalSquare(vector>& matrix) {

    4 if (matrix.size() == 0 || matrix[0].size() == 0) {

    5 return 0;

    6

    COMP40332021-03-11 21:33:19

    COMP4033 Assignment 1 - Basic Computer Graphics (5%)Due: 11:59pm, 13 March 2021Complete the following two exercises by writing a Java program for each:1. Draw a set of concentric pairs of squares, each consisting of a square with horizontal and vertical e

    【字符串哈希】Ybt_对称正方形2021-03-06 16:59:11

    题目大意

    给你一个n*m的矩阵,要你求这个矩阵内的左右上下都对称的子正方形共有多少个。

    把矩阵左右、上下镜面反过来,处理矩阵的哈希值。对比翻折前后的矩阵哈希值是否相等。 暴力枚举中心点,二分枚举矩阵大小。 (有单调性因为,当一个矩阵符合条件,以它的中心为中心的比他小的

    用C程序打印星形镂空正方形2021-03-04 09:04:44

    解题思路

    用5*5网格

    在第一行和最后一行,在所有列中打印星号,使用这个条件(i1||i5)

    从第二行到倒数第二行(用红色标记),在第一列行和最后一列打印星号,使用这个条件(j1||j5)如果条件不满足,打印空格。

    #include

    int main(){

    int i;

    int j;

    for(i=1;i<=5;i++){

    for(j=1;

    PTA团队天梯赛║L1-015 跟奥巴马一起画方块

    一、题目要求

    美国总统奥巴马不仅呼吁所有人都学习编程,甚至以身作则编写代码,成为美国历史上首位编写计算机代码的总统。2014年底,为庆祝“计算机科学教育周”正式启动,奥巴马编写了很简单的计算机代码:在屏幕上画一个正方形。现在你也

    判断四个点是否能构成正方形2021-02-10 19:31:36

    代码:

    #include

    #include

    #include

    using namespace std;

    struct point

    {

    double x, y;

    } a[4];

    bool Compare(point a, point b)

    {

    if (a.x != b.x)

    return a.x < b.x; //如果,横坐标不相等,所有点按横坐标升序排列

    return a.y < b.y;

    题目:

    给定一个矩阵,该矩阵只包含0和1,输出该矩阵中最大正方形区域的面积

    如:

    00011110

    00001111

    11101111

    最大是 3X3 的正方形,输出为 9

    解题:

    1.参考相关博客(链接见下文)

    先新建一个全为0,行数和列相等的列表 dp,设置一个最大值 maxSquare

    1)第一行和第一列,如果等于1,则dp对应的值

    221.最大正方形2021-01-26 19:01:23

    ### 解题思路

    dp[i][j]代表以位置(i,j)处的空格为正方形右下角的全为1的正方形的最大的边长。 dp[i][j]=min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1,if (dp[i][j]==1); dp[i][j]=0,if (dp[i][j]==0); 边界,dp[i][0]=1 if dp[i][0]==1 边界,dp[0][i]=1 if dp[i][0]==1

    959. 由斜杠划分区域

    Difficulty: 中等

    在由 1 x 1 方格组成的 N x N 网格 grid 中,每个 1 x 1 方块由 /、\ 或空格构成。这些字符会将方块划分为一些共边的区域。

    (请注意,反斜杠字符是转义的,因此 \ 用 "\\" 表示。)。

    返回区域的数目。

    示例 1:

    输入:

    [

    " /",

    "/ "

    ]

    输出:2

    72.打印正方形脚本2021-01-21 22:51:13

    思路:for内嵌实现打印正方形

    #!/bin/bash

    #The script is used to add square.

    #Date 2021-01-21

    while :

    do

    read -p "please input a number: " n

    n1=`echo $n |sed 's/[0-9]//g'`

    if [ -z $n ];then#判断输入是否为空

    echo "The input can not be empt

    字节跳动iOS开发实习生面试经历2021-01-19 16:34:51

    经过一周的面试和时间的沟通,终于通过并拿到offer

    作为一个开发者,有一个学习的氛围跟一个交流圈子特别重要,这是一个我的iOS交流群:812157648,不管你是小白还是大牛欢迎入驻 ,分享BAT,阿里面试题、面试经验,讨论技术, 大家一起交流学习成长!

    一面:

    1.指针和引用的区别

    2.虚函数和纯虚函数

    分巧克力(AcWing 1227)2021-01-17 21:33:28

    题目

    描述

    儿童节那天有 K 位小朋友到小明家做客。

    小明拿出了珍藏的巧克力招待小朋友们。

    小明一共有 N 块巧克力,其中第 i 块是 Hi×Wi 的方格组成的长方形。

    为了公平起见,小明需要从这 N 块巧克力中切出 K 块巧克力分给小朋友们。

    切出的巧克力需要满足:

    形状是正方形,边长是整数

    30.【打印正方形】2020-12-13 09:04:54

    输出格式

    A B C D E

    B C D E A

    C D E A B

    D E A B C

    E A B C D

    #include

    using namespace std;

    int main(){

    char c;

    for(int i=0;i<5;i++){

    for(int j=0;j<5-i;j++){

    c = 'A' + i + j;

    cout<

    }

    展开全文
  • 编写程序,输出n层正方形图案。正方形图案最外层是第层,每层用的数字和层数相同。例如,输入3那么输出为:1 1 1 1 11 2 2 2 11 2 3 2 11 2 2 2 11 1 1 1 1
  • 使用CSS在宽高不确定的父元素内画一个正方形

    需求:父元素宽高不确定,在内部画一个正方形

    <div class="box">
      <div class="inner"></div>
    </div>
    
    .box {
      /* 为了方便演示:这里设置成固定宽高了 */
      width: 200px; 
      height: 300px;
      border: 1px solid red;
    }
    
    .inner {
      /* 可以设置成100%或者其它的百分比 */
      width: 50%;
      padding-bottom: 50%;
      background-color: #007fff;
    }
    

    在这里插入图片描述
    原理:当padding 的取值是百分比的时候,它是相对于父元素的宽度; 一个div在没有明确设置高度,里边又没有内容的情况下,高度是0。所以我们可以在垂直方向上设置padding-top或者padding-bottom。注意设置padding-left或padding-right不会生效(因为子元素的高度依然是0)。

    前端学习交流QQ群,群内学习讨论的氛围很好,大佬云集,期待您的加入:862748629 点击加入

    展开全文
  • 确定4个点是否形成正方形29编写一个函数,该函数将平面上的4个点作为输入,并且如果4个点形成一个正方形,则返回true。这些点将具有绝对值<1000的积分坐标。您可以使用4点的任何合理表示形式作为输入。这些点没有...

    确定4个点是否形成正方形

    29

    编写一个函数,该函数将平面上的4个点作为输入,并且如果4个点形成一个正方形,则返回true。这些点将具有绝对值<1000的积分坐标。

    您可以使用4点的任何合理表示形式作为输入。这些点没有以任何特定顺序提供。

    最短的代码胜出。

    正方形示例:

    (0,0),(0,1),(1,1),(1,0) # standard square

    (0,0),(2,1),(3,-1),(1,-2) # non-axis-aligned square

    (0,0),(1,1),(0,1),(1,0) # different order

    非正方形示例:

    (0,0),(0,2),(3,2),(3,0) # rectangle

    (0,0),(3,4),(8,4),(5,0) # rhombus

    (0,0),(0,0),(1,1),(0,0) # only 2 distinct points

    (0,0),(0,0),(1,0),(0,1) # only 3 distinct points

    您可以为退化的平方返回true或false (0,0),(0,0),(0,0),(0,0)

    我们在这里谈论3D点,对吗?

    3

    @gnibbler了“ 的问题制作3D的平面”部分指出的可能性不大。

    分数是按顺序给出的吗?

    @JB,我当时以为这意味着这些点在一个平面上,但是由于某种原因,我在3D空间中看到了一个平面:)

    1

    @eBusiness:-1表示您投了11票:其中7票被拒绝。

    Answers:

    12

    Python 176 90 79字节

    def S(A):c=sum(A)/4.0;return set(A)==set((A[0]-c)\*1j\*\*i+c for i in range(4))

    函数S将复数列表作为其输入(A)。如果我们知道一个正方形的中心和一个角,则可以通过围绕中心点(c)旋转90,180和270度的角来重建正方形。在复平面上,通过将点乘以i可以绕原点旋转90度。如果我们的原始形状和重建的正方形具有相同的点,那么它一定是正方形。

    一些优化:1)使用“ S”代替“ is_square” 2)使用;将其全部放在一行上;3)直接在4个方向上迭代“ for i in(1,1j,-1,-1j)” 4)在set参数中不需要[]。

    谢谢基思。(我忽略了(3),因为它看起来与我的代码长度相同)

    2

    @Keith Randall-为什么当JB的解决方案要短得多时,这被接受了?

    1

    有两个原因。第一,J总是赢。所以我喜欢按语言归一化。另外,我更喜欢这个答案,因为它不会像其他答案(当然,只有非理性的答案)给出错误肯定的情况那样,受到与仅基于距离的答案相同的困扰。

    5

    @Keith Randall-问题引号:“这些点将具有整数坐标”“最短的代码获胜。”。如果您选择不同的条件来选择答案,甚至是主观条件,那也很好,但是您应该在问题中说明。

    13

    J,28 17 25 27

    J并没有真正的功能,但是这是一个单调动词,它从复杂平面中获取点向量:

    4 8 4-:#/.~&(/:~&:|&,&(-/~))

    方法是将迈克尔·斯宾塞(Michael Spencer)(仅在顶点间的长度上工作;但他目前无法使我的菱形2)和Eelvex(检查布景的大小)混合使用。从右到左阅读:

    -/~ 计算所有点差

    , 展平

    | 提取幅度

    /:~ 整理

    #/.~ 算数

    4 8 4 -:必须正好有4个等距距离(在0处),8个等距点(长度1,边),4个等距点(length sqrt 2,对角线)

    示范:

    NB. give the verb a name for easier use

    f =: 4 8 4-:#/.~&(/:~&:|&,&(-/~))

    NB. standard square

    f 0 0j1 1j1 1

    1

    NB. non-axis-aligned square

    f 0 2j1 3j_1 1j_2

    1

    NB. different order

    f 0 1j1 0j1 1

    1

    NB. rectangle

    f 0 0j2 3j2 3

    0

    NB. rhombus 1

    f 0 3j4 8j4 5

    0

    NB. rhombus 2

    f 0 1ad_60 1ad0 1ad60

    0

    为了记忆起见,我的上一个方法(必需的有序顶点,但可以检测任何顺序的规则多边形):

    *./&(={.)&(%1&|.)&(-1&|.)

    请参阅历史以获取解释和演示。当前方法可能会扩展到其他多边形,4 8 4看起来确实很像二项式分布。

    1

    @gnibbler:为什么不呢?我很确定。

    1

    实际上,确实存在一个满足您要检查的条件的非正方形图形,它是一个正三角形,加上从扩展中位数上的三角形的尖端到其边长的一个点。但是这个问题要求整数输入,所以我想解决方案是可以的。

    1

    喔好吧。我当时正在考虑以第四个点为中心的等边三角形,但是这被整数坐标所排除

    1

    您可以通过将其更改为显式定义来削减3个字符: 3 :'4 8 4-:#/.~/:~|,-/~y'

    5

    蟒蛇,71 42

    lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3

    更新1)要求4个不同的点(以前是否会给重复的点带来误报-还有其他点吗?)2)为每个规范定义一个函数

    对于正方形,任意两点之间的向量必须为0(同一点),边或对角线。因此,这些向量的大小集的长度必须为3。

    # Accepts co-ordinates as sequences of complex numbers

    SQUARES=[

    (0+0j,0+1j,1+1j,1+0j), # standard square

    (0+0j,2+1j,3-1j,1-2j), # non-axis-aligned square

    (0+0j,1+1j,0+1j,1+0j) # different order

    ]

    NONSQUARES=[

    (0+0j,0+2j,3+2j,3+0j), # rectangle

    (0+0j,3+4j,8+4j,5+0j), # rhombus

    (0+0j,0+1j,1+1j,0+0j), # duplicated point

    (0+0j,1+60j,1+0j,1-60j) # rhombus 2 (J B)

    ]

    test = "lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3"

    assert len(test)==71

    is_square=lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3

    for A in SQUARES:

    assert is_square(A)

    for A in NONSQUARES:

    assert not is_square(A)

    我认为该问题明确指出了要点列表,而不是向量。

    1

    那么(0 + 0j,0 + 0j,1 + 0j,0 + 1j)是一个正方形吗?

    我的菱形2不是1 +/- 60j,它更像exp(i j pi / 3)的值是-1、0、1。请注意,正如eBusiness指出的那样,它们不可能全部都是整数,所以并不是真的问题的范围。

    3

    Haskell,100个字符

    这就是我在Haskell中编写JB的J解决方案的方式。没有通过删除不必要的字符来破坏可读性的尝试,大约是132个字符:

    import Data.List

    d (x,y) (x',y') = (x-x')^2 + (y-y')^2

    square xs = (== [4,8,4]) . map length . group . sort $ [d x y | x

    您可以删除多余的空间并重命名一些内容,将其刮到100点以下

    import Data.List

    d(x,y)(a,b)=(x-a)^2+(y-b)^2

    s l=(==[4,8,4]).map length.group.sort$[d x y|x

    让我们使用QuickCheck来确保它接受任意正方形,其中一个顶点位于(x,y),边缘矢量(a,b):

    prop_square (x,y) (a,b) = square [(x,y),(x+a,y+b),(x-b,y+a),(x+a-b,y+b+a)]

    在ghci中尝试:

    ghci> quickCheck prop_square

    *** Failed! Falsifiable (after 1 test):

    (0,0)

    (0,0)

    哦,对了,这里的空正方形不算是正方形,因此我们将修改测试:

    prop_square (x,y) (a,b) =

    (a,b) /= (0,0) ==> square [(x,y),(x+a,y+b),(x-b,y+a),(x+a-b,y+b+a)]

    再试一次:

    ghci> quickCheck prop_square

    +++ OK, passed 100 tests.

    1

    展开此功能可节省11个字符d。s l=[4,8,4]==(map length.group.sort)[(x-a)^2+(y-b)^2|(x,y)

    3

    因子

    使用Factor编程语言的实现:

    USING: kernel math math.combinatorics math.vectors sequences sets ;

    : square? ( seq -- ? )

    members [ length 4 = ] [

    2 [ first2 distance ] map-combinations

    { 0 } diff length 2 =

    ] bi and ;

    和一些单元测试:

    [ t ] [

    {

    { { 0 0 } { 0 1 } { 1 1 } { 1 0 } } ! standard square

    { { 0 0 } { 2 1 } { 3 -1 } { 1 -2 } } ! non-axis-aligned square

    { { 0 0 } { 1 1 } { 0 1 } { 1 0 } } ! different order

    { { 0 0 } { 0 4 } { 2 2 } { -2 2 } } ! rotated square

    } [ square? ] all?

    ] unit-test

    [ f ] [

    {

    { { 0 0 } { 0 2 } { 3 2 } { 3 0 } } ! rectangle

    { { 0 0 } { 3 4 } { 8 4 } { 5 0 } } ! rhombus

    { { 0 0 } { 0 0 } { 1 1 } { 0 0 } } ! only 2 distinct points

    { { 0 0 } { 0 0 } { 1 0 } { 0 1 } } ! only 3 distinct points

    } [ square? ] any?

    ] unit-test

    3

    OCaml,145164

    let(%)(a,b)(c,d)=(c-a)*(c-a)+(d-b)*(d-b)

    let t a b c d=a%b+a%c=b%c&&d%c+d%b=b%c&&a%b=a%c&&d%c=d%b

    let q(a,b,c,d)=t a b c d||t a c d b||t a b d c

    像这样运行:

    q ((0,0),(2,1),(3,-1),(1,-2))

    让我们反混淆并解释一下。

    首先我们定义一个规范:

    let norm (ax,ay) (bx,by) = (bx-ax)*(bx-ax)+(by-ay)*(by-ay)

    您会注意到没有调用sqrt,在这里不需要。

    let is_square_with_fixed_layout a b c d =

    (norm a b) + (norm a c) = norm b c

    && (norm d c) + (norm d b) = norm b c

    && norm a b = norm a c

    && norm d c = norm d b

    这里,a,b,c和d是点。我们假设这些点的布局如下:

    a - b

    | / |

    c - d

    如果我们有一个正方形,那么所有这些条件都必须满足:

    abc是直角三角形

    bcd是直角三角形

    每个直角三角形的较小边具有相同的范数

    请注意,以下条件始终成立:

    is_square_with_fixed_layout r s t u = is_square_with_fixed_layout r t s u

    我们将使用它来简化下面的测试功能。

    由于我们的输入未排序,因此我们还必须检查所有排列。不失一般性,我们可以避免对第一点进行置换:

    let is_square (a,b,c,d) =

    is_square_with_fixed_layout a b c d

    || is_square_with_fixed_layout a c b d

    || is_square_with_fixed_layout a c d b

    || is_square_with_fixed_layout a b d c

    || is_square_with_fixed_layout a d b c

    || is_square_with_fixed_layout a d c b

    简化后:

    let is_square (a,b,c,d) =

    is_square_with_fixed_layout a b c d

    || is_square_with_fixed_layout a c d b

    || is_square_with_fixed_layout a b d c

    编辑:遵循了乔凡尼尼的建议。

    真好 我们在这里没有看到太多的OCaml :)

    使用运算符代替,n以减少20个字符:let t a b c d=a%b+a%c=b%c&&d%c+d%b=b%c&&a%b=a%c&&d%c=d%b。

    2

    巨蟒(105)

    点由(x,y)元组表示。点可以是任何顺序,并且只能接受正方形。创建s点之间成对(非零)距离的列表。在两个唯一的组中,总共应该有12个距离。

    def f(p):s = filter(None,[[(xz)** 2+(yw)** 2对于x,y在p中用于z,w在p中]]);返回len(s)== 12and len(集)== 2

    您可以省略过滤器,并检查集合的len是否为3。这也遭受了与我的回答相同的误报问题。

    >>> F([(0,0),(0,4),(2,2),( - 2,2)])= TRUE

    2

    f([(0,0),(0,4),(2,2),(-2,2)])是一个正方形

    2

    Python-42个字符

    看起来对点使用复数是一种改进

    len(set(abs(x-y)for x in A for y in A))==3

    其中A = [(11 + 13j),(14 + 12j),(13 + 9j),(10 + 10j)]

    旧答案:

    from itertools import*

    len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2

    点以任何顺序指定为列表,例如

    A = [(11, 13), (14, 12), (13, 9), (10, 10)]

    >>> A=[(0,0),(0,0),(1,1),(0,0)] >>> len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2 True

    @Sargun,这是一类无效的输入的特例。我试图考虑一种不会超出答案规模的解决方案。同时,可以算出失败案例的一般类别吗?

    A=[(0,0),(0,4),(2,2),(-2,2)]; len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2

    @Sargun:那个例子是一个正方形。

    要消除重复的点,可以添加-set([0])

    2

    C#-不完全短。滥用LINQ。在输入中选择不同的点的两个组合,计算它们的距离,然后验证它们中的四个正好相等,并且仅存在另一个不同的距离值。Point是具有两个双重成员X和Y的类。很容易成为Tuple,但是。

    var points = new List

    {

    new Point( 0, 0 ),

    new Point( 3, 4 ),

    new Point( 8, 4 ),

    new Point( 5, 0 )

    };

    var distances = points.SelectMany(

    (value, index) => points.Skip(index + 1),

    (first, second) => new Tuple(first, second)).Select(

    pointPair =>

    Math.Sqrt(Math.Pow(pointPair.Item2.X - pointPair.Item1.X, 2) +

    Math.Pow(pointPair.Item2.Y - pointPair.Item1.Y, 2)));

    return

    distances.Any(

    d => distances.Where( p => p == d ).Count() == 4 &&

    distances.Where( p => p != d ).Distinct().Count() == 1 );

    2

    PHP,82个字符

    //$x=array of x coordinates

    //$y=array of respective y coordinates

    /* bounding box of a square is also a square - check if Xmax-Xmin equals Ymax-Ymin */

    function S($x,$y){sort($x);sort($y);return ($x[3]-$x[0]==$y[3]-$y[0])?true:false};

    //Or even better (81 chars):

    //$a=array of points - ((x1,y1), (x2,y2), (x3,y3), (x4,y4))

    function S($a){sort($a);return (bool)($a[3][0]-$a[0][0]-abs($a[2][1]-$a[3][1]))};

    但是,仅仅因为边界框是正方形,并不意味着这些点位于正方形中。必要但不充分的条件。考虑(0,0),(5,5),(10,0),(0,-5)。边界框是正方形(0:10,-5:5); 图不是。

    2

    K -33

    {4 8 4~#:'=_sqrt+/'_sqr,/x-/:\:x}

    K在这里受其保留字(_sqr和_sqrt)的影响。

    测试:

    f:{4 8 4~#:'=_sqrt+/'_sqr,/x-/:\:x}

    f (0 0;0 1;1 1;1 0)

    1

    f 4 2#0 0 1 1 0 1 1 0

    1

    f 4 2#0 0 3 4 8 4 5 0

    0

    2

    OCaml +电池,132个字符

    let q l=match List.group(-)[?List:(x-z)*(x-z)+(y-t)*(y-t)|x,y2*s=d|_->false

    (看,Ma,没有空格!)列表理解以q表格形式列出了每个不同的无序点对的平方范数。一个正方形具有四个相等的边和两个相等的对角线,后者的平方长度是前者的平方长度的两倍。由于整数晶格中没有等边三角形,因此该测试并不是真正必要的,但出于完整性考虑,我将其包括在内。

    测试:

    q [(0,0);(0,1);(1,1);(1,0)] ;;

    - : bool = true

    q [(0,0);(2,1);(3,-1);(1,-2)] ;;

    - : bool = true

    q [(0,0);(1,1);(0,1);(1,0)] ;;

    - : bool = true

    q [(0,0);(0,2);(3,2);(3,0)] ;;

    - : bool = false

    q [(0,0);(3,4);(8,4);(5,0)] ;;

    - : bool = false

    q [(0,0);(0,0);(1,1);(0,0)] ;;

    - : bool = false

    q [(0,0);(0,0);(1,0);(0,1)] ;;

    - : bool = false

    2

    Mathematica 65 80 69 66

    检查不同点间距离的数量(不包括点到自身的距离)是否为2,并且两者中的较短者不为0。

    h = Length@# == 2 \[And] Min@# != 0 &[Union[EuclideanDistance @@@ Subsets[#, {2}]]] &;

    用法

    h@{{0, 0}, {0, 1}, {1, 1}, {1, 0}} (*standard square *)

    h@{{0, 0}, {2, 1}, {3, -1}, {1, -2}} (*non-axis aligned square *)

    h@{{0, 0}, {1, 1}, {0, 1}, {1, 0}} (*a different order *)

    h@{{0, 0}, {0, 2}, {3, 2}, {3, 0}} (* rectangle *)

    h@{{0, 0}, {3, 4}, {8, 4}, {5, 0}} (* rhombus *)

    h@{{0, 0}, {0, 0}, {1, 1}, {0, 0}} (* only 2 distinct points *)

    h@{{0, 0}, {0, 1}, {1, 1}, {0, 1}} (* only 3 distinct points *)

    正确

    正确

    正确

    错误

    False

    False

    False

    注意:\[And]是Mathematica中的单个字符。

    1

    您是在告诉我Mathematica没有内置的IsSquare函数吗?

    2

    果冻,8字节

    _Æm×ıḟƊṆ

    将复数列表作为命令行参数。打印1或0。

    _Æm Subtract mean of points from each point (i.e. center on 0)

    ×ıḟƊ Rotate 90°, then compute set difference with original.

    Ṇ Logical negation: if empty (i.e. sets are equal) then 1 else 0.

    这似乎是一个令人振奋的复兴挑战!

    1

    哈斯克尔(212)

    import Data.List;j=any f.permutations where f x=(all g(t x)&&s(map m(t x)));t x=zip3 x(drop 1$z x)(drop 2$z x);g(a,b,c)=l a c==sqrt 2*l a b;m(a,b,_)=l a b;s(x:y)=all(==x)y;l(m,n)(o,p)=sqrt$(o-m)^2+(n-p)^2;z=cycle

    天真的第一次尝试。检查点输入列表的所有排列的以下两个条件(给定排列表示点的顺时针排序):

    所有角度均为90度

    四边都一样长

    模糊化的代码和测试

    j' = any satisfyBothConditions . permutations

    --f

    where satisfyBothConditions xs = all angleIs90 (transform xs) &&

    same (map findLength' (transform xs))

    --t

    transform xs = zip3 xs (drop 1 $ cycle xs) (drop 2 $ cycle xs)

    --g

    angleIs90 (a,b,c) = findLength a c == sqrt 2 * findLength a b

    --m

    findLength' (a,b,_) = findLength a b

    --s

    same (x:xs) = all (== x) xs

    --l

    findLength (x1,y1) (x2,y2) = sqrt $ (x2 - x1)^2 + (y2 - y1)^2

    main = do print $ "These should be true"

    print $ j [(0,0),(0,1),(1,1),(1,0)]

    print $ j [(0,0),(2,1),(3,-1),(1,-2)]

    print $ j [(0,0),(1,1),(0,1),(1,0)]

    print $ "These should not"

    print $ j [(0,0),(0,2),(3,2),(3,0)]

    print $ j [(0,0),(3,4),(8,4),(5,0)]

    print $ "also testing j' just in case"

    print $ j' [(0,0),(0,1),(1,1),(1,0)]

    print $ j' [(0,0),(2,1),(3,-1),(1,-2)]

    print $ j' [(0,0),(1,1),(0,1),(1,0)]

    print $ j' [(0,0),(0,2),(3,2),(3,0)]

    print $ j' [(0,0),(3,4),(8,4),(5,0)]

    1

    Scala(146个字符)

    def s(l:List[List[Int]]){var r=Set(0.0);l map(a=>l map(b=>r+=(math.pow((b.head-a.head),2)+math.pow((b.last-a.last),2))));print(((r-0.0).size)==2)}

    1

    JavaScript 144个字符

    数学上等于J Bs的答案。它生成6个长度,并断言最大的2个相等,最小的4个相等。输入必须是一个数组数组。

    function F(a){d=[];g=0;for(b=4;--b;)for(c=b;c--;d[g++]=(e*e+f*f)/1e6)e=a[c][0]-a[b][0],f=a[c][1]-a[b][1];d.sort();return d[0]==d[3]&&d[4]==d[5]} //Compact function

    testcases=[

    [[0,0],[1,1],[1,0],[0,1]],

    [[0,0],[999,999],[999,0],[0,999]],

    [[0,0],[2,1],[3,-1],[1,-2]],

    [[0,0],[0,2],[3,2],[3,0]],

    [[0,0],[3,4],[8,4],[5,0]],

    [[0,0],[0,0],[1,1],[0,0]],

    [[0,0],[0,0],[1,0],[0,1]]

    ]

    for(v=0;v<7;v++){

    document.write(F(testcases[v])+"
    ")

    }

    function G(a){ //Readable version

    d=[]

    g=0

    for(b=4;--b;){

    for(c=b;c--;){

    e=a[c][0]-a[b][0]

    f=a[c][1]-a[b][1]

    d[g++]=(e*e+f*f)/1e6 //The division tricks the sort algorithm to sort correctly by default method.

    }

    }

    d.sort()

    return (d[0]==d[3]&&d[4]==d[5])

    }

    1

    PHP,161158个字符

    function S($a){for($b=4;--$b;)for($c=$b;$c--;){$e=$a[$c][0]-$a[$b][0];$f=$a[$c][1]-$a[$b][1];$d[$g++]=$e*$e+$f*$f;}sort($d);return$d[0]==$d[3]&&$d[4]==$d[5];}

    从问题陈述中还不清楚点是按顺序排列的。我去问问。

    1

    我认为这不会正确处理很多案件。例如,它将菱形错误地标记为正方形。

    更新了此内容以匹配JavaScript答案之一,应处理所有情况。

    1

    JavaScript 1.8,112个字符

    更新:通过将数组解析折叠在一起,保存了2个字符。

    function i(s)(p=[],[(e=x-a,f=y-b,d=e*e+f*f,p[d]=~~p[d]+1)for each([a,b]in s)for each([x,y]in s)],/8,+4/.test(p))

    JB答案的另一个重新实现。利用JavaScript 1.7 / 1.8功能(表达式闭包,数组理解,解构分配)。还滥用~~(双位非运算符)强制转换undefined为数字,使用数组到字符串强制转换和正则表达式来检查长度计数是否为[4, 8, 4](它假定恰好传递了4个点)。逗号运算符的滥用是一个古老的C技巧。

    测试:

    function assert(cond, x) { if (!cond) throw ["Assertion failure", x]; }

    let text = "function i(s)(p=[],[(e=x-a,f=y-b,d=e*e+f*f,p[d]=~~p[d]+1)for each([a,b]in s)for each([x,y]in s)],/8,+4/.test(p))"

    assert(text.length == 112);

    assert(let (source = i.toSource()) (eval(text), source == i.toSource()));

    // Example squares:

    assert(i([[0,0],[0,1],[1,1],[1,0]])) // standard square

    assert(i([[0,0],[2,1],[3,-1],[1,-2]])) // non-axis-aligned square

    assert(i([[0,0],[1,1],[0,1],[1,0]])) // different order

    // Example non-squares:

    assert(!i([[0,0],[0,2],[3,2],[3,0]])) // rectangle

    assert(!i([[0,0],[3,4],[8,4],[5,0]])) // rhombus

    assert(!i([[0,0],[0,0],[1,1],[0,0]])) // only 2 distinct points

    assert(!i([[0,0],[0,0],[1,0],[0,1]])) // only 3 distinct points

    // Degenerate square:

    assert(!i([[0,0],[0,0],[0,0],[0,0]])) // we reject this case

    1

    GoRuby-66个字符

    f=->a{z=12;a.pe(2).m{|k,l|(k-l).a}.so.go{|k|k}.a{|k,l|l.sz==z-=4}}

    扩展:

    f=->a{z=12;a.permutation(2).map{|k,l|(k-l).abs}.sort.group_by{|k|k}.all?{|k,l|l.size==(z-=4)}}

    与JB的答案相同的算法。

    测试像:

    p f[[Complex(0,0), Complex(0,1), Complex(1,1), Complex(1,0)]]

    输出true为true,空白为false

    @Jonas:我还没有看到任何真正正式的东西,我看到的最好的博客文章就是这一篇。实际上,我实际上无法使它构建和工作,但另一种方法是将golf-prelude复制到相同的文件夹中并运行ruby -r ./golf-prelude.rb FILE_TO_RUN.rb,并且工作原理完全相同。

    sort之前没有必要group_by。.sort.group_by {...}应该写为.group_by {...}

    1

    Python 97(无复杂点)

    def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

    这将以[(x,y),(x,y),(x,y),(x,y)]中的点元组的列表以任何顺序排列,并且可以处理重复项或错误的点数。它不需要像其他python答案一样的复杂点。

    您可以像这样测试它:

    S1 = [(0,0),(1,0),(1,1),(0,1)] # standard square

    S2 = [(0,0),(2,1),(3,-1),(1,-2)] # non-axis-aligned square

    S3 = [(0,0),(1,1),(0,1),(1,0)] # different order

    S4 = [(0,0),(2,2),(0,2),(2,0)] #

    S5 = [(0,0),(2,2),(0,2),(2,0),(0,0)] #Redundant points

    B1 = [(0,0),(0,2),(3,2),(3,0)] # rectangle

    B2 = [(0,0),(3,4),(8,4),(5,0)] # rhombus

    B3 = [(0,0),(0,0),(1,1),(0,0)] # only 2 distinct points

    B4 = [(0,0),(0,0),(1,0),(0,1)] # only 3 distinct points

    B5 = [(1,1),(2,2),(3,3),(4,4)] # Points on the same line

    B6 = [(0,0),(2,2),(0,2)] # Not enough points

    def tests(f):

    assert(f(S1) == True)

    assert(f(S2) == True)

    assert(f(S3) == True)

    assert(f(S4) == True)

    assert(f(S5) == True)

    assert(f(B1) == False)

    assert(f(B2) == False)

    assert(f(B3) == False)

    assert(f(B4) == False)

    assert(f(B5) == False)

    assert(f(B6) == False)

    def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

    tests(t)

    这将需要一些解释,但是总体思路是,正方形中的点(侧面,对角线,零(点与自身相比,点))之间只有三个距离:

    def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

    对于元组的列表p(x,y)

    使用set(p)删除重复项,然后测试长度

    获取点的每个组合(p中的a,b代表c,d中的d)

    获取每个点到每个其他点的距离列表

    使用设置检查只有三个唯一的距离-零(与自身相比的点)-边长-对角线长度

    要保存代码字符,我是:

    使用1个char函数名称

    使用1行函数定义

    不用检查唯一点的数量是4,而是检查不同点的长度是-1(节省== 3 ==)

    使用列表和元组解包获得p中的a,b以获得p中的c,d,而不是使用a [0],a [1]

    使用pow(x,.5)而不是包括数学来获取sqrt(x)

    不在)后放置空格

    不要将浮动的前导零

    我担心有人会找到打破这一点的测试案例。因此,请这样做,不适。例如,我只检查三个距离而不是进行abs()并检查边长和斜边的事实,似乎是一个错误。

    第一次我尝试编码高尔夫。如果我违反任何家庭规矩,请保持友善。

    1

    Clojure,159个字符。

    user=> (def squares

    [[[0,0] [0,1] [1,1] [1,0]] ; standard square

    [[0,0] [2,1] [3,-1] [1,-2]] ; non-axis-aligned square

    [[0,0] [1,1] [0,1] [1,0]]]) ; different order

    #'user/squares

    user=> (def non-squares

    [[[0,0] [0,2] [3,2] [3,0]] ; rectangle

    [[0,0] [3,4] [8,4] [5,0]]]) ; rhombus

    #'user/non-squares

    user=> (defn norm

    [x y]

    (reduce + (map (comp #(* % %) -) x y)))

    #'user/norm

    user=> (defn square?

    [[a b c d]]

    (let [[x y z] (sort (map #(norm a %) [b c d]))]

    (and (= x y) (= z (* 2 x)))))

    #'user/square?

    user=> (every? square? squares)

    true

    user=> (not-any? square? non-squares)

    true

    编辑:也要解释一下。

    首先定义一个规范,该规范基本上给出两个给定点之间的距离。

    然后计算第一个点到其他三个点的距离。

    对三个距离进行排序。(这允许点的任何顺序。)

    两个最短距离必须等于一个正方形。

    根据毕达哥拉斯定理,第三(最长)距离必须等于短距离平方和的平方根。

    (注意:不需要平方根,因此在上面保存的代码中。)

    1

    C#,107个字符

    return p.Distinct().Count()==4&&

    (from a in p from b in p select (a-b).LengthSquared).Distinct().Count()==3;

    点是包含点的Vector3D列表。

    计算所有点之间的所有距离的平方,如果恰好存在三种不同的类型(必须为0,某个值a和2 * a)和4个不同的点,则这些点将形成一个正方形。

    1

    Python,66岁

    将纸马的答案从76 提高到66:

    def U(A):c=sum(A)/4;d=A[0]-c;return{d+c,c-d,d*1j+c,c-d*1j}==set(A)

    1

    Python 2,49个字节

    lambdal:all(1j*z+(1-1j)*sum(l)/4inlforzinl)

    将四个复数的列表作为输入。将每个点围绕平均值旋转90度,并检查每个结果点是否在原始列表中。

    相同的长度(尽管在Python 3中使用较短{*l})。

    lambdal:{1j*z+(1-1j)*sum(l)/4forzinl}==set(l)

    如果那更短,为什么不使用Python 3?另外,如果允许在Python中返回任意的true / falsy值,^则可以使用代替==。

    @Joel Python 2在大多数情况下是首选,这是2011年以来的一个非常古老的挑战,当时Python 2几乎被认为是Python高尔夫。挑战是返回真还是假,所以我坚持了这一点。如果今天发布此消息,则可能会指定输出true / falsey或两个不同值之一,甚至可以通过OK假定默认情况下。

    1

    Tr[#^2]==Tr[#^3]==0&[#-Mean@#]&

    取得由复数表示的点的列表,计算第二和第三中心矩,并检查它们是否均为零。

    未打高尔夫球:

    S[p_] := Total[(p - Mean[p])^2] == Total[(p - Mean[p])^3] == 0

    要么

    S[p_] := CentralMoment[p, 2] == CentralMoment[p, 3] == 0

    证明

    此准则适用于整个复平面,而不仅适用于高斯整数。

    首先,我们注意到当点一起平移时,中心矩不会改变。对于一组要点

    P = Table[c + x[i] + I*y[i], {i, 4}]

    中心矩都独立于c(这就是为什么它们被称为Central):

    {FreeQ[FullSimplify[CentralMoment[P, 2]], c], FreeQ[FullSimplify[CentralMoment[P, 3]], c]}

    (* {True, True} *)

    其次,中心矩简单地依赖于一组点的整体复杂缩放(缩放和旋转):

    P = Table[f * (x[i] + I*y[i]), {i, 4}];

    FullSimplify[CentralMoment[P, 2]]

    (* f^2 * (...) *)

    FullSimplify[CentralMoment[P, 3]]

    (* f^3 * (...) *)

    这意味着,如果中心矩为零,则缩放和/或旋转点集将使中心矩等于零。

    第三,让我们证明前两个点固定的点列表的标准:

    P = {0, 1, x[3] + I*y[3], x[4] + I*y[4]};

    在什么条件下,第二和第三中心矩的实部和虚部为零?

    C2 = CentralMoment[P, 2] // ReIm // ComplexExpand // FullSimplify;

    C3 = CentralMoment[P, 3] // ReIm // ComplexExpand // FullSimplify;

    Solve[Thread[Join[C2, C3] == 0], {x[3], y[3], x[4], y[4]}, Reals] // FullSimplify

    (* {{x[3] -> 0, y[3] -> -1, x[4] -> 1, y[4] -> -1},

    {x[3] -> 0, y[3] -> 1, x[4] -> 1, y[4] -> 1},

    {x[3] -> 1/2, y[3] -> -1/2, x[4] -> 1/2, y[4] -> 1/2},

    {x[3] -> 1/2, y[3] -> 1/2, x[4] -> 1/2, y[4] -> -1/2},

    {x[3] -> 1, y[3] -> -1, x[4] -> 0, y[4] -> -1},

    {x[3] -> 1, y[3] -> 1, x[4] -> 0, y[4] -> 1}} *)

    所有这六个解都表示一个正方形:

    3cc71fad0fa46936ca3d276663afd6ac.png

    因此,形式的点列表{0, 1, x[3] + I*y[3], x[4] + I*y[4]}可以具有零个第二和第三中心矩的唯一方法是当四个点形成一个正方形时。

    由于点1和点2所示的平移,旋转和缩放属性,这意味着在第二和第三中心矩为零的任何时候,我们在某个平移/旋转/缩放状态下都有一个正方形。∎

    概括

    如果k不能被n整除,则规则n边的第k个中心矩为零。必须将这些条件中的足够多组合起来,以构成检测n边形的足够标准。对于n = 4的情况,在k = 2和k = 3的情况下检测零就足够了;为了检测六边形(n = 6),可能需要检查k = 2,3,4,5是否为零。我还没有证明以下内容,但怀疑它会检测到任何常规的n-gon:

    isregularngon[p_List] :=

    And @@ Table[PossibleZeroQ[CentralMoment[p, k]], {k, 2, Length[p] - 1}]

    代码挑战本质上是该代码专门用于长度为4的列表。

    该解决方案看起来相当有趣。您能解释一下为什么给出正确答案吗?

    @Joel我添加了一个证明。

    非常感谢。理想的情况是对该解决方案进行更直观的数学解释。

    @Joel我可以给您提供导致我找到此解决方案的线索。首先,我注意到正方形(作为坐标列表,而不是复数)具有与单位矩阵成比例的协方差矩阵。但是,此条件还不够(误报)。对于任何点对称结构,第三中心矩必须为零。因此,我转而使用复数表示法在第二和第三中心矩上设置了条件,令我惊讶的是,事实证明第二中心矩对于正方形为零。

    大。感谢您显示此解决方案的路径。

    0

    J,31 29 27 26

    3=[:#[:~.[:,([:+/*:@-)"1/~

    检查点之间的8个最小距离是否相同。

    检查点之间是否存在三种距离(零,边长和对角线长度)。

    f 4 2 $ 0 0 2 1 3 _1 1 _2

    1

    f 4 2 $ 0 0 0 2 3 2 3 0

    0

    4 2 $ 是用J编写数组的一种方法。

    这使菱形测试失败。

    @JB:我有错字。我现在还是改变了方法。

    哎呀...您使用的是我偷走的相同方法。除了我的版本更短:p

    @JB:真的吗?我没注意到。还有谁检查(3 == #distances)?

    @JB:oic ...对2的组合进行一些检查:://

    0

    Smalltalk为106个字符

    s:=Set new.

    p permutationsDo:[:e|s add:((e first - e second) dotProduct:(e first - e third))].

    s size = 2

    其中p是点的集合,例如

    p := { 0@0. 2@1. 3@ -1. 1@ -2}. "twisted square"

    我认为数学很合理...

    检查2个不同的点产品不会减少它。放置在相同位置的点可能会产生误报。

    0

    Mathematica,123个字符(但您可以做得更好):

    Flatten[Table[x-y,{x,a},{y,a}],1]

    Sort[DeleteDuplicates[Abs[Flatten[Table[c.d,{c,%},{d,%}]]]]]

    %[[1]]==0&&%[[3]]/%[[2]]==2

    其中“ a”是Mathematica列表形式的输入,例如: a={{0,0},{3,4},{8,4},{5,0}}

    关键是看点所有向量之间积,并注意它们对于x的某些值必须恰好具有三个值:0,x和2 * x。点积会检查一个膨胀管的垂直度和长度。

    我知道有一些Mathematica快捷方式可以使它更短,但我不知道它们是什么。

    我认为这也是错误的,但是我无法弄清楚代码的作用。

    它计算4个点之间的所有向量,取所有点积(绝对值),并期望结果对于x的某个值正好由0,x,2 * x组成。

    因此,有16个向量-> 256个点积,您要检查高值是低值的2倍,但您不必知道每个值有多少。是正确的理解吗?

    是的,正确描述了我的算法。我现在认为您是对的:您可以构建一个场景,其中所有3个值均出现,但数量不正确。老鼠 应该可以修复吗?

    @barrycarter您可以使用Union代替来保存字符Sort@DeleteDuplicates。我也将您的3条线放在一起:#[[1]] == 0 && #[[3]]/#[[2]] == 2 &[ Union@Abs@Flatten[Table[c.d, {c, #}, {d, #}]] &[ Flatten[Table[x - y, {x, a}, {y, a}], 1]]]

    0

    Haskell,“ wc -c”报告110个字符。不检查输入是否包含4个元素。

    import Data.List

    k [a,b]=2*a==b

    k _=0<1

    h ((a,b):t)=map (\(c,d)->(a-c)^2+(b-d)^2) t++h t

    h _=[]

    j=k.nub.sort.h

    我测试了

    test1 = [(0,0),(3,4),(-4,3),(-1,7)] -- j test1 is True

    test2 = [(0,0),(3,4),(-3,4),(0,8)] -- j test2 is False

    请注意,以上内容从未获得到点到自身的距离,因此距离0的存在将指示输入列表中的重复点,并且这将在排序列表中显示为k [0,b],因此2 * 0 == b就总是失败,因为b不能是相同的为0

    展开全文
  • Scratch案例-画正方形

    2020-07-22 17:22:03
    在舞台正中央绘制一个边长为200的正方形,要求: 1、围绕舞台中心绘制正多边形,均匀分布在四个象限中 2、正方形边长为200个单位,线条粗细、颜色自定 3、利用画笔绘制正方形,不能有多余的线条
  • 设置高度为0,width和padding-top的值相等,使用border,设置背景颜色。 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title></title> ...sty
  • 坐标点判断是否为正方形

    千次阅读 2021-05-26 02:56:03
    首先,我先选定三个点,判断这三个点是否可以构成一个等腰直角三角形(如果不是的话,肯定无法构成正方形的),在判断的同时,还要确定一下三个点(主要是直角的那个点);这样确定后,再利用第四个点验证一下就容易了....
  • 【深搜】给出一堆长度各异的木棍,这些木棍能否头尾相连形成一个正方形1.【题目描述】2.【代码】 1.【题目描述】 题目描述:给出一堆长度各异的木棍,这些木棍能否头尾相连形成一个正方形 样例输入: 3 4 1 1 1 1 5 ...
  • #include <stdio.h> #include <math.h> double juli(int a1,int a2,int b1,int b2) { double dis=0; dis= sqrt((a1-b1)*(a1-b1)+(a2-b2)*(a2-b2)); return dis; } int main() ... wh...
  • C++用*和空格输出一个正方形及其对角线分析代码思路:下面分析外层for里面的两个部分:1. if 的要求是能输出正方形的首行和尾行,则判断可写为:2. else这里用来分隔中间几行代码的输入。 零基础起步程序猿,人生中...
  • 算算总共多少正方形

    2019-02-21 12:20:19
    用C#完成计算过程(无聊的人) 代码实现以迭代假设每像素点作为正方形左上角 以确定正方形个数 可运行的程序在./bin/debug/xxx.exe
  • 如何实现一个宽度自适应的正方形

    千次阅读 2018-12-27 12:32:06
    外边距(margin)和内边距(padding)参照的都是包含块的宽度,需要注意的是上下边距并没有参照包含包含块的高度。div元素是p元素的包含块,p元素的margin和padding属性会参照div元素的宽度计算。...
  • = 0 && IsRightAngle(a[0], a[1], a[2]))//三个条件同时满足(1:四条边相等,2:边不为0,3:有一个直角) cout ; else cout ; cout ; } return 0; } 从文件中读取数据的代码如下: 在test.txt中第...
  • 判断四个点组成正方形。 三个条件: ...2.有一个直角(根据3个点组成的两个向量点乘为0) struct point { double x, y; } a[4]; bool cmp(point a, point b) { if (a.x != b.x) return a.x < b.x;...
  • 依赖于任何浮点计算(math.sqrt(x)或x ** ...幸运的是(如果一个人不急着;-)有很多纯粹的整数方法,如下面的…:def is_square(apositiveint):x = apositiveint // 2seen = set([x])while x * x != apositiveint:x =...
  • 我正在努力创建一个由均匀分布的正方形链组成的布局,这些正方形可以填充可用空间。使用Android Constraintlayout创建一排均匀分布的正方形我到底想要的布局,看起来像这样: 的想法是,与不同的宽高比手机这个...
  • 给定一个整数,确定它是否是正方形数字: 在数学中,平方数或正方形是整数,它是整数的平方; 换句话说,它是一些整数与自身的产物。 例如: isSquare(-1) returns false isSquare(0) returns true isSquare(3) ...
  • 类图Java 图,点,正方形,矩形,圆,三角形,类
  • 只需确定正方形边长len就可以唯一确定一个正方形。 使用动态规划求解,最重要的是找到状态转移方程 使用一个二维数组dp存储以(i,j)的右下标的正方形中,最大的正方形边长len: 逆向推: 假设最大正方形的右下角坐标...
  • 2)本题枚举每一种可能的最大边长b,然后随机看不同的左上角,也就是不同的正方形,有一个正方形合格,就返回b 3)笔试求AC,可以不考虑空间复杂度,但是面试既要考虑时间复杂度最优,也要考虑空间复杂度最优。 ...
  • 满意答案xumei_xumei2013.09.07采纳率:51%等级:12已帮助:5929人第一个要求的第(4),是计算圆形面积还是计算正方形面积?我按计算正方形面积给你做的…… 注意:我默认你的学号为01,你可以自己修改的!SquareFrame....
  • 一、如何绘制一个任意大小的正方形:import turtle bob=turtle.Turtle() #turtle模块提供了一个叫作Turtle的函数,用于创建一个Turtle对象 bob._delay=1 def square(t,length): for i in range(4): t.fd(length) #...
  • 因此,我试图编写一个简单的方法来获取四个坐标的集合并确定它们是否形成正方形.我的方法是从一个点开始并计算其他三个点与基点之间的距离.可以得到具有相同值的两个边和一个对角线.然后我用毕达哥拉斯定理确定边的...
  • 机器人走正方形教学案例

    千次阅读 2021-05-22 03:03:34
    机器人走正方形教学案例教学目标:知识目标:使学生理解循环语句在程序设计中的作用能力目标:通过程序设计及调试培养学生创新能力情感目标:培养互相协作的能力和不怕失败的科学精神教学对象分析及教法设计:学生应...
  • //要考虑正方形是倾斜的情况 #include<iostream> #include<algorithm> #include<cmath> using namespace std; struct point { double x, y; } a[4]; bool cmp(point a, point b) { if (a.x != b...
  • 有N坐标,求能构成正方形的数量(dfs)
  • excel绘制有实虚线的方框(一个立方体)开-条件格式->通过判定行号的奇偶性从而进式设定。具体步:你说的格式下拉填那种也可以,但是格式下来后填充整个sheet,保存后你会发现变成几M了,当然,条件格式...
  • 书山有路勤为径,学海无涯苦作舟点赞再看,养成习惯目录1....当他面对块矩形材料时,他总是从中间切割刀,切出块最大的正方 形,剩下块矩形,然后再切割剩下的矩形材料,直到全部切为正方形为止。 ...
  • 面试官:请说一下如何实现自适应正方形 纯CSS实现自适应正方形的几种方式 在写页面布局时候正方形对我们来说应该很常见,比如商品列表展示,头像展示, 在微博上发布图片的展现等 方法: 原理同...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,575
精华内容 12,630
热门标签
关键字:

如何确定一个正方形