通过插入减少主要因素的数量

12

给定两个正整数甲和乙，返回的位置p的是最小化的所得到的整数的素因子（计数多重）的数量，当乙被插入在一个在p。

例如，给定A = 1234和B = 32，这些是可能的插入（p为0索引）以及有关其主要因子的相应信息：

p | 结果 主要因素| Ω（N）/计数

0 | 321234 | [2，3，37，1447] | 4
1 | 132234 | [2，3，22039] | 3
2 | 123234 | [2，3，19，23，47] | 5
3 | 123324 | [2，2，3，43，239] | 5
4 | 123432 | [2，2，2，3，37，139] | 6

您可以看到，当p为1 时，结果具有最小数量的质因子3。因此，在这种情况下，应输出1。

眼镜

  • 如果有多个位置p使结果最小化，则可以选择输出所有位置p或其中的任何一个。

  • 您可以为p选择0索引或1索引，但是此选择必须一致。

  • A和B可以视为整数，字符串或数字列表。

  • 您可以使用任何编程语言进行竞争，并且可以通过任何标准方法接受输入并提供输出，同时请注意，默认情况下，这些漏洞是禁止的。这是代码高尔夫球，因此最短的提交（以字节计）获胜！

测试用例

A，B-> p（0索引）/ p（1索引）

1234、32-> 1/2
3456，3-> 4/5
378，1824-> 0/1
1824，378-> 4/5
67，267->以下任意一项或全部：[1，2] / [2，3]
435，1->以下任意一项或全部：[1、2、3] / [2、3、4]
378100，1878980901->以下任意一项或全部：[5，6] / [6，7]

为了方便起见，以下是表示每对输入的元组列表：

[(1234, 32), (3456, 3), (378, 1824), (1824, 378), (67, 267), (435, 1), (378100, 1878980901)]
code-golf  number-theory  primes  integer 
— Xcoder先生
source
1
我感觉这偏向于05AB1E ...
— Caird coinheringaahing
1
我们可以输出最小化素因数的结果数而不是插入索引吗？例如在您的第一个测试用例中132234而不是1。
— dylnan '18
2
@dylnan这次我要说不。
— Xcoder先生18年

Answers:

8

外壳，16字节

§◄öLpr§·++⁰↑↓oΘŀ

期望以字符串形式输入，请在线尝试！

说明

§◄(öLpr§·++⁰↑↓)(Θŀ)  -- input A implicit, B as ⁰ (example "1234" and "32")
§ (           )(  )  -- apply A to the two functions and ..
  (ö          )      --   | "suppose we have an argument N" (eg. 2)
  (    §      )      --   | fork A and ..
  (         ↑ )      --     | take N: "12"
  (          ↓)      --     | drop N: "34"
  (     ·++⁰  )      --   | .. join the result by B: "123234"
  (   r       )      --   | read: 123234
  (  p        )      --   | prime factors: [2,3,19,23,47]
  ( L         )      --   | length: 5
  (öLpr§·++⁰↑↓)      --   : function taking N and returning number of factors
                            in the constructed number
               ( ŀ)  --   | range [1..length A]
               (Θ )  --   | prepend 0
               (Θŀ)  --   : [0,1,2,3,4]
 ◄                   -- .. using the generated function find the min over range
— ბიმო
source
7

MATL，25个字节

sh"2GX@q:&)1GwhhUYfn]v&X<

输入是相反顺序的字符串。输出基于1。如果有平局，则输出最低位置。

在线尝试！或验证所有测试用例。

说明

s         % Implicitly input B as a string. Sum (of code points). Gives a number
h         % Implicitly input A as a string. Concatenate. Gives a string of length
          % N+1, where N is the length of A
"         % For each (that is, do N+1 times)
  2G      %   Push second input
  X@      %   Push 1-based iteration index
  q       %   Subtract 1
  :       %   Range from 1 to that. Gives [] in the first iteration, [1] in
          %   the second, ..., [1 2 ... N] in the last
  &)      %   Two-output indexing. Gives a substring with the selected elements,
          %   and then a substring with the remaining elements
  1G      %   Push first input
  whh     %   Swap and concatenate twice. This builds the string with B inserted
          %   in A at position given by the iteration index minus 1
  U       %   Convert to string
  Yf      %   Prime factors
  n       %   Number of elements
]         % End
v         % Concatenate stack vertically
&X<       % 1-based index of minimum. Implicitly display
— 路易斯·门多
source
6

Pyth，20 13 11字节

.mlPsXbQzhl

在线尝试

说明

.mlPsXbQzhl
.m    b         Find the minimum value...
         hl     ... over the indices [0, ..., len(first input)]...
  lP            ... of the number of prime factors...
    sX Qz       ... of the second input inserted into the first.
3

Japt，22 21字节

就在我撰写本文时，这感觉太久了，但是，从其他解决方案的角度来看，它似乎有些竞争。不过，可能还有一些改进的空间- cNq)特别是让我很烦。解释如下。

将第一个输入作为字符串，将第二个输入作为整数或字符串。结果为0索引，如果有多个解决方案，则将返回第一个索引。

ÊÆiYVÃcNq)®°k Ê
b@e¨X

尝试一下

说明

      :Implicit input of string U and integer V.
Ê     :Get the length of U.
Æ     :Generate an array of the range [0,length) and map over each element returning ...
iYV   :  U with V inserted at index Y.
à    :End mapping
c     :Append ...
Nq    :  The array of inputs joined to a string.
®     :Map over the array.
°     :Postfix increment - casts the current element to an integer.
k     :Get the prime divisors.
Ê     :Get the length.
\n    :The newline allows the array above to be assigned to variable U.
b     :Get the first index in U that returns true ...
@     :  when passed through a function that ...
e     :    checks that every element in U...
¨     :    is greater than or equal to...
X     :    the current element.
      : Implicit output of resulting integer.
— 毛茸茸
source
2

PowerShell，228字节

param($a,$b)function f($a){for($i=2;$a-gt1){if(!($a%$i)){$i;$a/=$i}else{$i++}}}
$p=@{};,"$b$a"+(0..($x=$a.length-2)|%{-join($a[0..$_++]+$b+$a[$_..($x+1)])})+"$a$b"|%{$p[$i++]=(f $_).count};($p.GetEnumerator()|sort value)[0].Name

在线尝试！

（似乎很长，建议打高尔夫。最后一个测试用例在TIO上也超时，但是该算法在该情况下应该没有问题。）

PowerShell没有内置的素数分解函数，因此它借鉴了我对Prime Factors Buddies的回答。那是第一行的function声明。

我们接受输入$a,$b，然后将其设置$p为空哈希表。接下来，我们将字符串$b$a带入，使用逗号运算符将其转换为单例数组,，并使用stuff将其数组连接。这些东西是一个循环$a，$b在每个点插入，最后与数组连接$a$b。

此时，我们$b在中的每个点都有一个插入数组$a。然后，我们通过for循环发送该数组|%{...}。每次迭代，我们插入到我们的哈希表的位置$i++的.count多少主要因素f是特定的元素$_了。

最后，我们sort基于values 的哈希表，取其0第一个，然后选择其Name（即$i索引的）。剩下的就在管道上，输出是隐式的。

— AdmBorkBork
source
2

05AB1E，27 21字节

ηõ¸ì¹.sRõ¸«)øεIýÒg}Wk

在线尝试！

它返回最低的0索引p。

感谢@Enigma -6个字节！

说明

ηõ¸ì                  # Push the prefixes of A with a leading empty string -- [, 1, 12, 123, 1234]
    ¹.sRõ¸«)          # Push the suffixes of A with a tailing empty space. -- [1234, 123, 12, 1, ]
            ø         # Zip the prefixes and suffixes
             ε    }   # Map each pair with...
              IýÒg    # Push B, join prefix - B - suffix, map with number of primes
                   Wk # Push the index of the minimum p
— 卡尔多
source
1
使用相同的方法，可以通过将其重写为来节省6个字节ηõ¸ì¹.sRõ¸«)øεIýÒg}Wk。
— Emigna
1

干净，165个 ... 154个字节

import StdEnv,StdLib
@n h#d=hd[i\\i<-[2..h]|h rem i<1]
|d<h= @(n+1)(h/d)=n
?a b=snd(hd(sort[(@0(toInt(a%(0,i-1)+++b+++a%(i,size a))),i)\\i<-[0..size a]]))

在线尝试！

— 巨大
source
0

JavaScript（ES6），120字节

将输入作为2个字符串。返回0索引位置。

f=(a,b,i=0,m=a)=>a[i>>1]?f(a,b,i+1,eval('for(n=a.slice(0,i)+b+a.slice(i),x=k=2;k<n;n%k?k++:n/=x++&&k);x')<m?(r=i,x):m):r

测试用例

显示代码段

— Arnauld
source
0

J，60字节

4 :'(i.<./)#@q:>".@(,(":y)&,)&.>/"1({.;}.)&(":x)"0 i.>:#":x'

显式二元组。在右边取B，在左边取A。

0索引输出。

不用盒子可以改善。

说明：

  4 :'(i.<./)#@q:>".@(,(":x)&,)&.>/"1({.;}.)&(":y)"0 i.>:#":y'  | Whole program
  4 :'                                                       '  | Define an explicit dyad
                                                     i.>:#":y   | Integers from 0 to length of y
                                                  "0            | To each element
                                     ({.;}.)&(":y)              | Split y at the given index (result is boxed)
                     (,(":x)&,)&.>/"1                           | Put x inbetween, as a string
                  ".@                                           | Evaluate
                 >                                              | Unbox, makes list
             #@q:                                               | Number of prime factors of each
      (i.>./)                                                   | Index of the minimum
— Bolce Bussiere
source
0

Python 3，128个字节

0索引；将字符串作为参数。-6个字节感谢Jonathan Frech。

from sympy.ntheory import*
def f(n,m):a=[sum(factorint(int(n[:i]+m+n[i:])).values())for i in range(len(n)+1)];return a.index(min(a))
— 0WJYxW9FMN
source
:\n a-> :a。
— 乔纳森·弗雷希
0

Python，122字节

f=lambda n,i=2:n>1and(n%i and f(n,i+1)or 1+f(n/i,i))
g=lambda A,B:min(range(len(A)+1),key=lambda p:f(int(A[:p]+B+A[p:])))

实际上，这很快超过了默认的最大递归深度。

— 用户名
source
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.