Questions tagged «array-manipulation»

取一个由数字或数组组成的数组，如果只包含2s 则输出。 输出应为真或假值（很抱歉，如果这样会破坏答案） 真实的测试案例 [2] [2,2] [[2],[2,2],2] [] [[],[]] 虚假测试用例 [1] [22] [2,2,2,1] [[1,2],2] 禁止使用标准漏洞。 默认IO规则适用。 代码高尔夫球，最少字节获胜！

20 code-golf  array-manipulation  decision-problem 

编写一个程序，确定给定的矩阵是否表示一个量子点。甲quandle是配备有单个（非可交换的，非结合）操作◃其遵循以下公理一组： 该操作已关闭，这意味着a◃b = c如果a和b是的元素。 该操作是自行分配的： (a◃b)◃c = (a◃c)◃(b◃c)。 操作是右整除：对于任何选择的对a和b，有单个唯一的c，使得c◃a = b 该操作是幂等的： a◃a = a 有限量子可以表示为方矩阵。以下是5阶夸德（source）的示例。 0 0 1 1 1 1 1 0 0 0 3 4 2 4 3 4 2 4 3 2 2 3 3 2 4 位于第n行第m列（索引为0）的值是n◃m的值。例如，在这个难题中，4◃1 = 3。从这个矩阵很容易看出一些量子特性： 由于只有值0-4出现在此5x5矩阵中，因此它是封闭的。 这是幂等的，因为矩阵对角线是0 1 2 3 4 …

20 code-golf  math  array-manipulation  abstract-algebra 

启发自查找列表的“展开大小”。 将RS不包含任何列表的列表的“递归大小”定义为其长度（包含的项目数），将包含任何列表的列表的“递归大小”定义为其长度与这些列表的递归大小之和。 挑战 编写一个程序或函数，以尽可能少的字节输出任何给定列表的递归大小。 输入是一个列表，可以包含数字，字符串（如果您的语言中有字符串）和类似列表。 例如： RS([]) = 0 RS([[]]) = 1 RS([4, 5, 6]) = 3 RS(["four", "five", "six"]) = 3 RS(["[[[[]]]]", "[][][][][]", "][][[[]]][]["]) = 3 RS([[4, 5, 6]]) = 4 RS([["four", "five", "six"]]) = 4 RS([["[[[[]]]]", "[][][][][]", "][][[[]]][]["]]) = 4 RS([[4], [5], [6]]) = 6 RS([["four"], ["five"], ["six"]]) …

20 code-golf  array-manipulation  counting 

此问题是从最初在Quora上提出的问题（不是针对代码高尔夫球）“启发”而来的。我只想对你们挑战（这是我在这里提交的第一个问题）。 给定一个整数元素数组v和一个整数d（我们假设d小于或等于数组的长度），请考虑该数组中所有d连续元素的序列。对于每个序列，计算该序列中元素的最大值和最小值之间的差，并将其命名为偏差。 您的任务是编写一个程序或函数，以计算上述所有序列的所有偏差中的最大值，然后返回或输出该值。 解决的示例： v: (6,9,4,7,4,1) d: 3 The sequences of length 3 are: 6,9,4 with deviation 5 9,4,7 with deviation 5 4,7,4 with deviation 3 7,4,1 with deviation 6 Thus the maximal deviation is 6, so the output is 6. 这是代码高尔夫，所以最短的答案以字节为单位。

20 code-golf  math  array-manipulation  optimization 

给定一个索引列表和零个或多个整数列表，输出按升序排列的整数列表，键优先级来自第一个输入。 例 令键输入为[1, 0, 2]，列表输入为[[5, 3, 4], [6, 2, 1], [5, 2, 1]]。这些列表需要按其第二元素，然后是第一个元素，然后是第三个元素，以升序排序： 首先，我们按index处的值排序1：[[6, 2, 1], [5, 2, 1], [5, 3, 4]] 接下来，我们使用index处的值打破第一个排序的关系0：[[5, 2, 1], [6, 2, 1], [5, 3, 4]] 最后，我们用索引处的vlues打破所有剩余的联系2（这实际上并没有改变任何东西，因为没有剩余的联系）。 细节 排序是稳定的：如果两个元素相对于给定的排序键比较相等，则它们必须在输出中保持相同的相对顺序。例如，在给定的排序键下，如果A和B相等，则输入was为[..., A, ..., B, ...]，A必须放在B输出中。 排序键永远不会引用输入列表之一中不存在的元素。 不会重复排序键。因此，[1, 2, 1]不是排序键的有效列表。 排序键未引用的任何元素均不计入排序顺序。只有初始相对顺序和排序键引用的元素的值才能确定输出顺序。 您可以选择排序键是零索引还是一索引。 排序键中将没有负值。如果选择使用单索引，则排序键中也不会有零。 整数值不会超出您的语言的本机表示范围。如果您选择的语言具有本地固有的任意精度整数（例如Python）的能力，则输入整数可以存在任何整数值，但要受内存限制。 参考实现（Python 2） #!/usr/bin/env python …

20 code-golf  number  array-manipulation  sorting 

任务是生成从“ a”到“ 999”的所有字符串，包括大写字符，如下所示： 'a', 'b', 'c' ... 'y', 'z', 'A', 'B', 'C' ... 'Y', 'Z', '0', '1', 2' ... '8', '9', 'aa', 'ab', 'ac' ... 'az', 'aA', 'aB' ... 'aZ', 'a0' ... 'a9', 'ba' 等等（填补空白），可以选择从空字符串开始。 输入： 程序必须打印到的连续字符数。 输出： 包含每个字符串或每行一个字符串的数组 说明： 顺序无关紧要，可以根据需要先打印大写或小写字母。 输出可以返回任何可枚举的类型，不必专门是数组，尽管我怀疑打印所有组合不是最简单的方法。 的输入3将打印所有从字符串'a'（或''）至'999'的输入5最多'99999'等。

20 code-golf  string  number  array-manipulation 

背景 想象一下，您从事一项令人烦恼的工作。每天早晨，您会收到一系列应该在当天进行的任务。每个任务都有一定的持续时间，一旦开始，就必须一次性完成。您的老板不会容忍闲置，因此，如果有一些任务仍然可以在回家之前完成，则必须处理其中一项（您可以选择其中一项）。相反，如果所有其他任务都需要您加班，那么您就可以早点回家！因此，您的目标是通过明智的安排来最大程度地减少工作时间。 有趣的事实：这是懒惰的官僚调度问题的一种变体，它是NP-hard（来源）。 输入值 您有两个输入：工作日中“时间单位”的数量（正整数L）和任务集合（正整数的非空数组T，表示任务持续时间）。它们可以以任何顺序以任何合理的格式进行使用。该数组T可以包含持续时间大于的任务L，但是可以保证至少包含一个持续时间最多的任务L。 输出量 一个有效的计划是任务的一个子集S ⊆ T，从而sum(S) ≤ L，而不是在每一个任务S（计重数）的持续时间严格不止L - sum(S)。您的输出应为有效计划的最小可能总和。换句话说，您将输出您今天必须工作的最小时间单位。 例 考虑输入 L = 9 T = [3,4,4,4,2,5] 安排一天的一种方式是[4,4]：您以8个时间为单位完成两项任务，还剩下1个单元。由于没有可用的1单元任务，因此您可以回家。但是，时间表[2,5]甚至更好：您以7个时间单位工作，然后所有其余任务将以3个或更多时间单位工作。该时间表[2,4]无效，因为在工作了6个时间单位后，您仍然有足够的时间来完成3个单位的任务。最佳状态为7个单位，因此正确的输出为7。 规则和计分 您可以编写完整的程序或函数。最低字节数获胜，并且不允许出现标准漏洞。没有时间限制，因此蛮横强制是完全可以接受的。 测试用例 这些以格式给出L T -> output。 1 [1,2] -> 1 6 [4,1] -> 5 7 [7,7,9] -> 7 9 [3,4,4,4,2,5] -> 7 20 [6,2,3,12,7,31] -> 17 42 …

20 code-golf  array-manipulation  optimization 

给定一个矩阵，输出矩阵的表示形式，其中左上角元素在顶部，反对角线是中心行，右下角元素在底部。 例如，考虑以下矩阵： 1 2 3 4 5 6 7 8 9 此矩阵的菱形版本为： 1 4 2 7 5 3 8 6 9 输入和输出 输入矩阵将作为列表列表（或您选择的语言中的任何类似内容）给出。输出也应该是列表列表。 矩阵将仅包含正整数。 输入矩阵不一定是正方形。 输入矩阵将至少为1×1。 测试用例 Input: [[1]] Output: [[1]] Input: [[1,2],[3,4]] Output: [[1],[3,2],[4]] Input: [[1,2,3],[4,5,6]] Output: [[1],[4,2],[5,3],[6]] Input: [[11,2,5],[3,99,3],[4,8,15],[16,23,42]] Output: [[11],[3,2],[4,99,5],[16,8,3],[23,15],[42]] 计分 这是代码高尔夫球，因此最短的答案以字节为单位。

20 code-golf  array-manipulation  matrix 

背景 我有一排强力磁铁和一堆金属物体。磁铁会将磁铁拉到哪里？ 输入值 您的输入是一个非负整数数组，其中将至少包含一个1。您可以使用任何合理的格式。 0数组的s表示空白，而1s表示固定的磁体。所有其他数字都是金属物体，它们被磁铁拉动。每个对象都被拉向最近的磁铁（如果有领带，则该对象被拉到右侧），然后沿该方向行进，直到碰到磁铁或另一个对象。最后，所有物体都聚集在磁铁周围。对象的顺序被保留。 输出量 您的输出是一个数组，其中每个对象都被拉到尽可能靠近最近的磁铁的位置。它应该具有与输入相同的格式。 例 考虑数组 [0,0,2,0,1,1,0,2,0,3,0,5,0,1,0] 最左边2的磁铁被拉向第一对磁铁，第二个磁铁也被拉向2。在3有磁铁在两个方向上四步走，所以它被拉到正确的。该5也被拉到右边，它会之间3和磁铁。正确的输出是 [0,0,0,2,1,1,2,0,0,0,0,3,5,1,0] 规则和计分 您可以编写完整的程序或函数。最低字节数获胜，并且不允许出现标准漏洞。 测试用例 [0,1,0] -> [0,1,0] [1,0,2,0,0,1,0] -> [1,2,0,0,0,1,0] [7,0,5,0,0,1,0] -> [0,0,0,7,5,1,0] [1,0,3,0,1,0,3,0,1] -> [1,0,0,3,1,0,0,3,1] [1,0,0,0,0,0,0,7,3] -> [1,7,3,0,0,0,0,0,0] [1,2,3,4,5,6,7,8,9,10,11,0,0,0,1] -> [1,2,3,4,5,6,7,0,0,0,8,9,10,11,1] [12,3,0,0,1,0,1,3,0,0,6,12,0,0,0,1] -> [0,0,12,3,1,0,1,3,6,0,0,0,0,0,12,1]

20 code-golf  array-manipulation 

这是星期一早上的快速挑战... 用最少的字节数写一个函数或程序： 输入[x,y]坐标列表 输入[x,y]坐标各自质量的列表作为输入 以形式输出计算出的质心[xBar,yBar]。 注意： 输入可以采用任何形式，只要使用数组即可。 质心可以通过以下公式计算： 用简单的英语... 为了找到xBar，将每个质量乘以其相应的x坐标，对结果列表求和，然后将其除以所有质量的总和。 要找到yBar，将每个质量乘以其各自的y坐标，对结果列表求和，然后将其除以所有质量的总和。 简单的Python 2.7示例： def center(coord, mass): sumMass = float(reduce(lambda a, b: a+b, mass)) momentX = reduce(lambda m, x: m+x, (a*b for a, b in zip(mass, zip(*coord)[0]))) momentY = reduce(lambda m, y: m+y, (a*b for a, b in zip(mass, zip(*coord)[1]))) xBar …

20 code-golf  arithmetic  array-manipulation 

介绍 编写一个完整的程序，该程序将ASCII字符的矩形块顺时针旋转90度。当程序本身顺时针旋转90度时，它将ASCII字符块逆时针旋转90。 规则 许多人不使用旋转或转置矩阵的内置函数。例如，在MATLAB / Octave中rot90，'不允许使用转置运算符。 您必须编写一个使用STDIN和STDOUT或最接近的等效语言的完整程序。 您的程序必须为矩形，并假定输入也是矩形。 输入和输出是用换行符分隔的字符串，并且没有尾随的换行符。 当将其源代码作为输入运行时，您的程序必须将自身顺时针旋转90度。输出必须是使用相同语言的第二个程序，该程序将其输入逆时针旋转90度。当旋转的程序被提供其源代码作为输入时，它应输出原始程序的源代码。 注意：这两个程序都必须能用于任何输入，而不仅仅是它们自己的源代码，因此不允许一个字符的quine。 例 说下面是一个有效的程序，它以一种假设的语言ExampleLang将输入旋转90度。 ^f a2% 3 lk (^_^& v D8 $4 / 当以自身作为输入运行时，它将输出另一个有效程序，该程序将其输入逆时针旋转： D l^ 8 kf $ (a 4 ^2 _% ^ /v&3 当第二个程序作为输入提供给自己时，输出原始程序。请注意，空白行应有四个空格，倒数第二行上有一个尾随空格，不能在markdown中呈现。澄清： $ examplelang program < program > rotProg $ examplelang rotProg < rotProg > program1 $ …

20 code-golf  restricted-source  array-manipulation  source-layout 

您将获得一个多维整数数组。每个尺寸都有固定的尺寸（因此，如果尺寸为2D，则始终为矩形）。您的程序应计算每个维度中的总和，并将该总和作为该维度中新的最后一项附加。 假设输入和输出数组为A和B，并且A 的维度i的大小为n i。B将具有与A相同的维数，并且维i的大小将为n i +1。B j 1，j 2，...，j m是A k 1，k 2，...，k m的和，其中： ķ 我 = j的我如果j 我 <= N 我 如果j i = n i +1 则0 <k i <= n i 对于输入： [[1 2 3] [4 5 6]] 您的程序（或函数）应输出： [[1 2 3 6] [4 5 6 15] …

20 code-golf  number  array-manipulation 

任务很简单。为*语言编写口译员。 这是Wiki的更大链接。 只有三个有效的*程序： * 打印“ Hello World” * 打印0到2,147,483,647之间的随机数 *+* 永远运行。 根据此问题的规范，第三种情况必须是无限循环 输入： 可以通过我们的标准I / O规则通过任何可接受的输入方法进行输入 它将永远是以上程序之一 输出： 第一种情况应打印准确Hello World，带有或不带有尾行。 对于第二种情况，如果您的语言的整数最大值小于2,147,483,647，请使用您的语言的整数最大值 根据我们的标准I / O规则，第一种情况和第二种情况可以打印到任何可接受的输出。 第三种情况不应给出任何输出。 得分： 因为这是代码高尔夫球，所以最短的答案（以字节为单位）获胜。

20 code-golf  interpreter  code-golf  array-manipulation  sorting  code-golf  halting-problem  code-golf  javascript  code-golf  algorithm  code-golf  arithmetic  code-golf  math  counting  code-golf  math  code-golf  decision-problem  radiation-hardening  code-golf  conversion  bitwise  code-golf  number  decision-problem  code-golf  string  decision-problem  code-golf  random  game  code-golf  ascii-art  graphical-output  code-golf  decision-problem  binary-tree  tree-traversal  code-challenge  array-manipulation  code-challenge  graphical-output  path-finding  test-battery  algorithm  code-golf  integer  factorial  code-golf  binary-tree  code-golf  grid  graph-theory  code-golf  regular-expression  quine  code-golf  encoding  code-golf  king-of-the-hill  javascript 

介绍 在这个挑战中，您的任务是确定给定的数字序列是否可以分为两个子序列，其中一个在增加，另一个在减少。例如，考虑序列8 3 5 5 4 12 3。它可以分为两个子序列，如下所示： 3 5 5 12 8 4 3 第一行的子序列增加，第二行的子序列减少。此外，您应该有效地执行此任务。 输入项 您的输入是一个非空L的整数列表，范围在0到99999（含）之间。它以您的语言的本机格式给出，或仅由空格分隔。 输出量 如果L可以分解为递增和递减子序列，则输出为真值，否则为假值。子序列不必严格增加或减少，它们中的任何一个都可以是空的。 规则和奖金 您可以编写完整的程序或函数。最低字节数获胜，并且不允许出现标准漏洞。此外，在此挑战中禁止强行使用：您的程序必须在输入长度内以多项式时间运行。 您不需要实际返回这两个子序列，但是这样做有-20％的奖金。为了使奖金更容易以静态类型的语言申领，可以为伪造的实例返回一对空列表。 测试用例 input -> None以错误输入和input -> inc dec真实输入的格式给出。这里只给出一对可能的子序列。可能还有更多。 [4,9,2,8,3,7,4,6,5] -> None [0,99999,23423,5252,27658,8671,43245,53900,22339] -> None [10,20,30,20,32,40,31,40,50] -> None [49,844,177,974,654,203,65,493,844,767,304,353,415,425,857,207,871,823,768,110,400,710,35,37,88,587,254,680,454,240,316,47,964,953,345,644,582,704,373,36,114,224,45,354,172,671,977,85,127,341,268,506,455,6,677,438,690,309,270,567,11,16,725,38,700,611,194,246,34,677,50,660,135,233,462,777,48,709,799,929,600,297,98,39,750,606,859,46,839,51,601,499,176,610,388,358,790,948,583,39] -> None [0,1,2,3,4] -> [0,1,2,3,4] [] [4,3,2,1,0] -> [] [4,3,2,1,0] …

20 code-golf  array-manipulation  subsequence  decision-problem  restricted-complexity 

我最近在工作时遇到一个问题，我有两个列表：一个主列表和一个较小的列表，其中包含主列表中项目的子集，可能以不同的顺序排列。我需要对主列表进行重新排序，以使子集中的项目以相同的顺序出现，而不更改列表中未找到的项目的顺序，并尽可能将项目保持在同一位置。好吧，这听起来可能令人困惑，所以我将其分解： 主清单定义了项目的默认顺序。 子集列表定义某些项目的相对顺序。 如果主列表中有两个元素按照子集列表的顺序排列不正确，则应将主列表中较早的项目移到最早的索引，该索引相对于子集列表中的其他项目位于正确的位置。（即紧接在后面的项目之后） 您的任务是实现此重新排序算法。 示例测试用例 Master: [1, 2, 3] Subset: [] Result: [1, 2, 3] Master: [9001, 42, 69, 1337, 420] Subset: [69] Result: [9001, 42, 69, 1337, 420] Master: [9001, 42, 69, 1337, 420, 99, 255] Subset: [69, 9001, 1337] Result: [42, 69, 9001, 1337, 420, 99, 255] …

19 code-golf  array-manipulation