programmedpatterns

模式识别练习，适合初学者和中级程序员。

它使用了Fawn Nguyen在https://www.visualpatterns.org/上的模式。网站和此模块在Creative Commons Attribution许可证下授权。

模式不是按难度排序的。许多很简单，一些非常难。

此模块目前处于建设中，尚不可用。

安装

要使用pip安装，从命令提示符/终端运行

python -m pip install programmedpatterns

解决编程练习

安装后，您可以通过调用 progpat.exercise(X) 来找到461个编程练习，其中 X 是1到461。例如

>>> import progpat
>>> progpat.exercise(1)
    Exercise #1
    1  2   3    4     5      6       7        8
    O  OO  OOO  OOOO  OOOOO  OOOOOO  OOOOOOO  OOOOOOOO
       OO  OOO  OOOO  OOOOO  OOOOOO  OOOOOOO  OOOOOOOO
           OOO  OOOO  OOOOO  OOOOOO  OOOOOOO  OOOOOOOO
                OOOO  OOOOO  OOOOOO  OOOOOOO  OOOOOOOO
                      OOOOO  OOOOOO  OOOOOOO  OOOOOOOO
                             OOOOOO  OOOOOOO  OOOOOOOO
                                     OOOOOOO  OOOOOOOO
                                              OOOOOOOO
    Number of Os:
    1  4   9    16    25     36      49       64

每个练习都有一个视觉字符串组件和一个数字数学组件。要解决练习，您必须编写两个函数。视觉字符串组件函数必须命名为 visX()，其中 X 是练习编号。数字数学组件函数必须命名为 numX()，其中 X 是练习编号。

例如， vis1(3) 应返回字符串 'OOO\nOOO\nOOO'，因为这将是练习#1的第3步的视觉字符串模式。同时， num1(3) 应返回 9，因为这是练习#1的第3步的数字数学组件。您的两个函数应返回传递给它们的任何整数（大于0）的正确答案。

您可以在progpat.exercise()显示的字符串中识别您应该计数的内容。例如，练习 #1 要求计数 O 的数量。大多数练习都要求计数 O，但有些练习要求计数其他字符或线段数量。

视觉字符串的行末没有尾随空格。它们使用句点（.）字符而不是空格来使间距更容易计数。

要检查您的代码是否正确，请从包含您的visX()和numX()函数的.py文件中运行以下内容

import progpat
progpat.check(1, vis1, num1)  # Checks the vis1() and num1() functions for correctness.

请注意，您正在传递函数本身，而不是调用它们。这就是为什么它们的名字后面没有括号（()）。

最终，我想建立一个网站来跟踪人们的解决方案（类似于 Advent of Code 所做的那样）。

贡献

目前需要大量的基本编程工作（在 Python 和其他语言中）来使 Programmed Patterns 的工作。

首先，我们需要所有 468 个图案的解决方案。每个解决方案由一个返回图案 X 在迭代 n 的多行字符串的 visX(n) 函数和一个返回图案 X 在迭代 n 的形状数量的 numX(n) 函数组成。

例如，这是难度中等的图案 #5

Pattern #5
    1    2      3        4          5            6
    .OO  ..OOO  ...OOOO  ....OOOOO  .....OOOOOO  ......OOOOOOO
    O.O  ...OO  ....OOO  .....OOOO  ......OOOOO  .......OOOOOO
    OOO  O..OO  ....OOO  .....OOOO  ......OOOOO  .......OOOOOO
         OOOO   O...OOO  .....OOOO  ......OOOOO  .......OOOOOO
         OOO    OOOOO    O....OOOO  ......OOOOO  .......OOOOOO
                OOOO     OOOOOO     O.....OOOOO  .......OOOOOO
                OOOO     OOOOO      OOOOOOO      O......OOOOOO
                         OOOOO      OOOOOO       OOOOOOOO
                         OOOOO      OOOOOO       OOOOOOO
                                    OOOOOO       OOOOOOO
                                    OOOOOO       OOOOOOO
                                                 OOOOOOO
                                                 OOOOOOO
    Number of Os:
    7    15     27       43         63           87

您编写的vis5()函数应接受一个整数n并返回迭代n的图案的多行字符串

def vis5(n):
    result = ''
    result += ('.' * n) + ('O' * (n + 1)) + '\n'
    for i in range(n - 1):
        result += ('.' * (n + 1)) + ('O' * n) + '\n'
    result += 'O' + ('.' * n) + ('O' * n) + '\n'
    result += 'O' * (n + 2) + '\n'
    for i in range(n - 1):
        result += 'O' * (n + 1) + '\n'
    return result

您编写的num5()函数应接受一个整数n并返回迭代n的图案中'O'字符的数量

def num5(n):
    return 3 + (2 * ((n + 1) * n))

这些函数将用于检查学生解决方案。每个图案谜题都有一个视觉字符串操作组件和一个数学代数组件。这对于已经学习了语言语法但需要提高编写代码技能的初级程序员来说提供了大量的练习。

您能帮忙的地方是编写未解决的图案的解决方案函数。查看https://visualpatterns.org，并找到一个图案来编写函数解决方案。为了避免在其他人在做的工作上工作，通过在 Python 中运行 random.randint(1, 468)（或任何其他随机选择方法）来随机选择要解决的图案，然后检查 GitHub 存储库以确保它尚未被解决。

源代码文件有模板 visX() 和 numX() 函数，您可以用您的解决方案来填充它们。然后您可以通过运行 _getPatternMultilineString(X, 1, 10)（其中 X 是图案编号）来验证解决方案在迭代 1 到 10 之间看起来是否正确。

虽然 visX() 函数返回的字符串是多行的（即它们包含 \n 换行字符），但每一行都应该移除所有尾随空格以获得规范答案。例如，这个模式

O
OO
OOO

....应表示为'O\nOO\nOOO'，而不是'O \nOO \nOOO\n'。

您还应尽可能地将每个图案画在顶部和左侧。例如，图案 #22 的第 2 次迭代应该是 'O\nOO'，而不是 '\n\nO\nOO'。

一旦您完成了图案的视觉和数字函数并确保它们是正确的，请向函数的def语句添加一个# DONE注释，并将视觉函数的文档字符串更新为getPatternMultilineString(patternNum, 1, endIteration)的输出，其中patternNum是图案编号的整数，endIteration是尽可能大的整数，但输出不会超过大约 70 或 80 个字符。（这通常是 3 到 6。）重要的是您使用命名模式visX()和numX()为您的解决方案函数或getPatternMultilineString()将无法正常工作。

特殊情况图案

大多数图案涉及通用形状的渐进式增长，这些形状由 'O' 字符串表示。例如

图案 #9

O    OO    OOO    OOOO    OOOOO
OO   OOO   OOOO   OOOOO   OOOOOO
OOO  OOOO  OOOOO  OOOOOO  OOOOOOO
Number of Os:
6    9     12     15      18

图案 #11

O   O    O     O      O
OO  O    O     O      O
    OOO  O     O      O
         OOOO  O      O
               OOOOO  O
                      OOOOOO
Number of Os:
3   5    7     9      11

图案 #14

O       O       O       O       O
OOOOOO  OOOOOO  OOOOOO  OOOOOO  OOOOOO
        OOOOOO  OOOOOO  OOOOOO  OOOOOO
                OOOOOO  OOOOOO  OOOOOO
                        OOOOOO  OOOOOO
                                OOOOOO
Number of Os:
7       13      19      25      31

但是，一些模式有多种形状。例如，模式#15

Pattern #15
1    2      3        4          5            6
.O   .O.O   .O.O.O   .O.O.O.O   .O.O.O.O.O   .O.O.O.O.O.O
OXO  OXOXO  OXOXOXO  OXOXOXOXO  OXOXOXOXOXO  OXOXOXOXOXOXO
.O   .O.O   .O.O.O   .O.O.O.O   .O.O.O.O.O   .O.O.O.O.O.O
Number of Os, Xs:
(4, 1)(7, 2) (10, 3)  (13, 4)    (16, 5)      (19, 6)

在这些情况下，除了'O'之外，还会使用其他字母，如'X'来增加视觉效果。对于数字组件，numX()函数返回的不是简单的整数，而是一组整数。对于模式#15，返回的元组格式为(O的数量, X的数量)。

其他模式有线条图而不是离散的形状。例如，模式#44看起来像这样

Pattern #44
1           2                 3
....__      ....__....__      ....__....__....__
.__/##\__   .__/##\__/##\__   .__/##\__/##\__/##\__
/##\##/##\  /##\##/##\##/##\  /##\##/##\##/##\##/##\
\##/..\##/  \##/..\##/..\##/  \##/..\##/..\##/..\##/
/##\__/##\  /##\__/##\__/##\  /##\__/##\__/##\__/##\
\##/##\##/  \##/##\##/##\##/  \##/##\##/##\##/##\##/
...\##/     ...\##/..\##/     ...\##/..\##/..\##/
Number of filled hexagons:
6           10                14

这些模式通常使用/、\、_和|作为线条绘制字符。在许多编程语言中，当在代码中的字符串字面量中写入时，\正斜杠必须被转义为\\。在Python中，原始字符串是一个有用的快捷方式，允许您在不转义的情况下写入正斜杠：print(r'Hello\\world')将打印Hello\\world而不是Hello\world。

然而，Python在语言设计上有一个小缺陷，即反斜杠不能是原始字符串的最后一个字符。代码print(r'\Hello\')会产生语法错误，而不是显示\Hello\。在这些情况下，您不能使用原始字符串，而必须使用带有转义字符的正常字符串：print('\\Hello\\')

如果您想为此git仓库做出贡献，请通过al@inventwithpython.com或Twitter @AlSweigart与我联系。

如何解决编程模式

待办事项 - 完成此部分，提供解决这些问题的建议。（例如，注意迭代之间的变化，包括数量，记住您将按从左到右打印，逐行分解，使用循环进行多行，使用字符串重复进行同一行上的多个字符等。）

支持

如果您觉得这个项目很有帮助，并想支持其开发，请考虑在Patreon上向其创作者捐赠。