数组分解

13

给定一个正整数数组，输出这些整数的不同素数的稳定数组。换句话说，对于输入中的每个整数，按顺序获取其质数因子，对其进行排序，然后将输出中尚未存在的任何质数附加到输出中。

测试用例

[1,2,3,4,5,6,7,8,9,10] -> [2,3,5,7]
[10,9,8,7,6,5,4,3,2,1] -> [2,5,3,7]
[100,99,98,1,2,3,4,5] -> [2,5,3,11,7]
[541,60,19,17,22] -> [541,2,3,5,19,17,11]
[1,1,2,3,5,8,13,21,34,45] -> [2,3,5,13,7,17]
[6,7,6,7,6,7,6,5] -> [2,3,7,5]
[1] -> []
[8] -> [2]
[] -> []

输出可以是整数或字符串的数组或列表，定界输出或输出数字的有序列表的任何其他标准方式。

这是代码高尔夫球，因此最短答案以字节为单位。

code-golf  array-manipulation  primes 
— 史提芬
source
— 斯蒂芬（Stephen）
5
这是我认为“太简单”的挑战之一。几乎每个答案都将是以下答案之一：（a）输入的循环，以及带有条件追加的Ye Olde素因分解代码；（b）四个内置链。创造力没有太大的余地。也许答案会证明我错了，但我对此表示怀疑。在这里，高尔夫几乎没有什么比素数分解要多的了，而这已经做完了。
— 林恩
1
@Lynn对于打高尔夫球的郎很琐碎，但对其他所有事情都不小。不知道这是否是微不足道的理由：/
— Stephen
您能告诉我1的“主要因素”是什么吗？
— J42161217 '17
1
@DigitalTrauma是的。否则，它将仅仅是“输出输入的所有素数的集合”
— Stephen

Answers:

5

Bash + GNU实用程序，37

  • 感谢@muru节省了21个字节（哇！）
factor|tr \  \\n|awk '!/:/&&!a[$0]++'

在线尝试。

— 数字创伤
source
1
我认为nl|sort|...可以使用awk：（awk '!a[$0]++'节省打印时间，如果以前没有看到过，那么顺序就不会丢失），可以节省15个字节。然后sed可以使用稍长的命令来消除该命令awk：（factor|awk '!/:/&&!a[$0]++' RS='[ \n]+'在空格和换行符上分割记录，用跳过记录:），再保存4个字节。
— muru
1
我刚刚意识到，我可以使用tr:（factor|tr \ \\n|awk '!/:/&&!a[$0]++'在第一个反斜杠之后的两个空格）在前面的注释中保存另外两个字节
— muru 17/08/30
@muru很棒-谢谢！（如果您将其作为自己的答案发布，我不会感到沮丧，这大大超出了我的原著）
— Digital Trauma
4

MATL，6个字节

"@Yfvu

在线尝试！

说明：

"      % Loop over input
 @     % Push the array element
  Yf   % Prime factors
    v  % Concatenate entire stack vertically (does nothing the first iteration)
     u % Stably get distinct (unique, in MATLAB terminology) elements. Does so every loop but this is code golf, not fastest code.

有趣的MATL花絮：通常，所有函数都同样容易地应用于向量（数组）。但是在这种情况下，每个输入的因子数量是可变的，因此Matlab和扩展的MATL通常仅处理平方矩阵，因此我不得不使用for循环"。

此外，MATL有两个主要的串联运算符：h和和v，水平和垂直串联。它们的行为差异很大：v连接整个堆栈，即使它只有一个元素（如我们的第一次迭代）也是如此。h正好包含两个元素，如果仅存在一个元素，则将失败，从而使其不适用于此应用程序。

— 桑切斯
source
3

PowerShell，102字节

param($x)$a=@();$x|%{$a+=(2..($z=$_)|?{!($z%$_)-and'1'*$_-match'^(?!(..+)\1+$)..'}|sort)};$a|select -u

在线尝试！

（从TessellatingHeckler的借用因式分解想法回答了关于“我后边去吧撒旦总理！”）

将输入作为文字数组$x。创建一个新的空数组$a。循环结束$x。每次迭代，我们都会循环从2当前数开始，检查该因子是否-and为质数，然后|sort将其输出，并将其附加到$a。当我们完成经历$x，我们再输出$a，但|select只有-u其NIQUE号码。这利用了唯一性从左到右，并保持第一次出现的事实，该问题与问题描述相匹配。这些数字留在管道上，并且输出是隐式的。

— AdmBorkBork
source
3

CJam，11个字节

{:mfe__&1-}

该函数接受一个整数数组并输出一个整数数组。

测试版本

— 土风
source
如何区分多个字符的输出？至少对于我的（在线）测试而言，它输出的是字符串，而不是整数数组。
— 斯蒂芬，
作为一个函数，它的输出数据类型是一个整数数组。CJam自动打印该堆栈，并打印不包含斜线的数组。我不知道这对您的目的是否足够。如果需要分度计，请S*在右方括号内添加。
— geokavel
我相信基于堆栈的lang仍然可以通过ToS输出，所以很好，我只是想知道。谢谢。
— 斯蒂芬，
2

Mathematica，64个字节

Select[DeleteDuplicates[First/@FactorInteger@#~Flatten~1],#>1&]&

输入

[{100，99，98，1，2，3，4，5}]

— J42161217
source
Select[#&@@@Gather[#&@@@Join@@FactorInteger@#],#>1&]&
— matrix89
2

Haskell，77个字节

import Data.List
x!y|y>x=[]|x`mod`y<1=y:(x`div`y)!y|1<2=x!(y+1)
nub.((!2)=<<)

说明：

  • 在x!y运营商的回报的所有主要因素的列表x是大于或等于y
  • 该(!2)函数返回其参数的所有主要因素的列表
  • 最后一行的功能实现了所需的功能

在线尝试。

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source
2

Brachylog，6个字节

ḋᵐoᵐcd

在线尝试！

说明

ḋᵐ         Map prime decomposition
  oᵐ       Map order
    c      Concatenate
     d     Remove duplicates
— 致命
source
费伊斯[10,9,8,7,6,5,4,3,2,1]。应该是[2, 5, 3, 7]，不是[2, 3, 5, 7]
— Xcoder先生17年
您可以将其修复为+1字节：ḋᵐoᵐcd
— Xcoder先生，17年
@ Mr.Xcoder谢谢，已修复。相当愚蠢的要求imo。
— 致命
这并不是什么荒谬的事，因为它微不足道，微不足道。我也发布了自己的答案，但是我首先使用了反向而不是顺序。不确定为什么素数逆序生成？
— Xcoder先生17年
@Fatalize好-挑战不是“对列表中的不同主要因素进行排序”，而是“在列表中反复列出并添加不同的主要因素”。
— 斯蒂芬，
2

Japt，6个字节

mk c â

测试一下

说明

数组的隐式输入U。在（m）上映射（），获取k每个元素的因子（）。展平（c），获取唯一元素（â）并隐式输出。

— 毛茸茸
source
2

Python 3中，128个125 116字节

这是一个纯Python解决方案。没有包裹。感谢Halvard节省了9个字节。

def f(l):y=[k for i in l for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))];print(sorted({*y},key=y.index))

在线尝试！

Python 2中，133个127 126字节

def f(l):y=sum([[k for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))]for i in l],[]);print sorted(set(y),key=y.index)

在线尝试！

Python 2中，142个138 134字节

l=input();r=[]
for i in sum([[k for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))]for i in l],[]):r+=[i]*(i not in r)
print r

在线尝试！

非常惊讶的是还没有Python的答案。打高尔夫球。

— Xcoder先生
source
— Halvard Hummel
@HalvardHummel谢谢
— Xcoder先生17年
2

Deorst，16个字节

EDkE]l1FeFPkEQE_

在线尝试！

在Deorst聊天室的@cairdcoinheringaahing帮助下完成（请注意，解决方案有所不同）。

说明

EDkE] l1FeFPkEQE_完整程序。

ED推送每个元素的除数列表。
  k防止堆栈重新排序。
   E]展平堆栈。
     l1Fe从堆栈中删除1s（因为caird冲了进来并加了1个质数！）-应该在将来的语言版本中删除。
         FP保持素数。
           k防止堆栈重新排序。
            EQ重复数据删除。
              E_输出结果。
— Xcoder先生
source
2

Deorst，16个字节

EDkE]EQFPkl1FeE_

在线尝试！

在@ Mr.Xcoder的帮助下完成。对于伪高尔夫语言来说，这太长了。

怎么运行的

EDkE]EQFPkl1FeE_ - Full program, implicit input: [1,2,3,4,5]

ED               - Get divisors. Vectorizes. STACK = [[1], [1,2], [1,3], [1,2,4], [1,5]]
  k              - Turn off sorting for the next command
   E]            - Flatten the stack. STACK = [1, 1, 2, 1, 3, 1, 2, 4, 1, 5]
     EQ          - Deduplicate stack in place. STACK = [1, 2, 3, 4, 5]
       FP        - Filter by primality 1 is considered prime. STACK = [1, 2, 3, 5]
         k       - Turn off sorting for the next command
          l1     - Push 1. STACK = [1, 2, 3, 5, 1]
            Fe   - Filter elements that are equal to the last element. STACK = [2, 3, 5]
              E_ - Output the whole stack
— 开斋节
source
1

MY，17个字节

⎕Ḋḟ’⊢f(‘53ǵ'ƒf(ū←

在线尝试！

怎么样？

  • ⎕ 评估输入
  • Ḋ 除数（向量化/求整）
  • ḟ 展平
  • ’⊢f(‘减量，过滤器，增量（去除1）
  • 53ǵ''P'MY的代码页中的字符串，这是素数测试。可悲的0x35=53是第16个素数，并且没有用于将16堆栈> _ < 压入堆栈的命令。
  • ƒ 作为功​​能
  • f( 通过那个过滤
  • ū 统一
  • ← 输出
— 扎查里
source
1

C ++，118字节

[](auto n){decltype(n)r;for(int m:n)for(int i=1,j;i++<m;){j=m%i;for(int x:r)j|=!(i%x);if(!j)r.push_back(i);}return r;}

需要将输入传递给std::vector<int>，返回另一个std::vector<int>作为输出。

— 录象机
source
1

Python 2中，88个 119 103字节

开始了。用正确的排序。

def f(l,s=[]):[s.append(x) for x in sum([list(primefac(i)) for i in l],[]) if x not in s];print s
from primefac import*

显然我无法在TIO上使用它，因为不支持该软件包。它确实可以在我的机器上运行。这是我的测试输出：

f([1,2,3,4,5,6,7,8,9,10],[])     #[2, 3, 5, 7]
f([10,9,8,7,6,5,4,3,2,1],[])     #[2, 5, 3, 7]
f([100,99,98,1,2,3,4,5],[])      #[2, 5, 3, 11, 7]
f([541,60,19,17,22],[])          #[541, 2, 3, 5, 19, 17, 11]
f([1,1,2,3,5,8,13,21,34,45],[])  #[2, 3, 5, 13, 7, 17]
f([6,7,6,7,6,7,6,5],[])          #[2, 3, 7, 5]
f([1],[])                        #[]
f([8],[])                        #[2]
f([],[])                         #[]

不知何故，我无法使该函数成为lambda函数。每当我尝试返回列表解析时，它都会返回[None，None，...]。如果我只是忽略某件事，有人可以指出那个错误吗？感谢您的反馈！

编辑：

使用Xcoders排序算法，我可以将代码减少16个字节。谢谢你的那部分。

from primefac import*
def f(l):a=sum([list(primefac(i))for i in l],[]);print sorted(set(a),key=a.index)
— 西蒙
source
这似乎是不正确的。第二个测试用例应该输出[2, 5, 3, 7]。输出的顺序很重要。
— Mego
sorted(set().union(*map(primefac,l)))
— 亚历克斯·霍尔
输出的顺序很重要。重新阅读说明，或查看其他答案-我真的不知道该怎么解释。
— 斯蒂芬，
@斯蒂芬。更新了例程，输出正确。我花了一段时间才注意到每一行的差异。阅读时集中精力很有帮助。
— 西蒙（Simon）
@Simon通过删除括号后的空格来节省三个字节s.append(x) for--> s.append(x)for，primefac(i)) for-> primefac(i))for，[]) if->[])if
— Stephen
1

Braingolf，7个字节

&(p)u=;

在线尝试！

哦，看，基本上是四个内置链接

说明

&(p)u=;  Implicit input from commandline args
 (.)     Sandbox loop, sandboxes each item in a separate stack and runs the
         code within the loop.
&        Append the entire sandboxed stack when loop ends, rather than only the
         top of stack after each iteration
  p      Prime factors
    u    Unique
     =   Print stack
      ;  Suppress implicit output
— Skidsdev
source
失败[10,9,8,7,6,5,4,3,2,1]。-订单很重要：您应该返回[2, 5, 3, 7]而不是[2, 3, 5, 7]。
— Xcoder先生17年
您可以将其固定为-1个字节。由于K只在这里造成伤害。
— Xcoder先生17年
@ Mr.Xcoder哦，是的，没有意识到它们应该按照出现的顺序而不是升序排列。固定
— Skidsdev
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.