두 개의 양의 정수 주어 및 B 의 복귀 쪽 이 최소화 얻어진 정수의 소인수 (다중성 계수)의 수 B가 되고 삽입 에 에서 P .

예를 들어, A = 1234 및 B = 32 이면 가능한 삽입 ( p 는 0으로 색인화 됨)과 해당 주요 요인에 대한 해당 정보입니다.

p | 결과 | 주요 요인 | Ω (N) / 카운트

0 | 321234 | [2, 3, 37, 1447] | 4
1 | 132234 | [2, 3, 22039] | 삼
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 에 대해 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)]

껍질 , 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

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

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.

젤리 , 21 바이트

D©L‘Ṭœṗ¥€®żF¥€VÆfL€NM

온라인으로 사용해보십시오!

Xcoder 씨께 -1 감사합니다 .

가능한 모든 위치를 반환합니다.

apt , 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.

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++에서 해시 테이블에 삽입 합니다..countf$_

마지막으로, 우리 sort는 values에 기초한 해시 테이블을 가지고, 0그것의 하나를 취하고 그것의 Name(즉, $i인덱스의)를 선택합니다. 그것은 파이프 라인에 남아 있으며 출력은 암시 적입니다.

05AB1E , 18 바이트

gƒ¹õ«N¹g‚£IýÒg})Wk

온라인으로 사용해보십시오!

05AB1E , 27 21 바이트

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

온라인으로 사용해보십시오!

가장 낮은 0 인덱스 p를 반환합니다 .

-6 바이트를위한 @Enigma에게 감사합니다!

설명

ηõ¸ì                  # 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

클린 , 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]]))

온라인으로 사용해보십시오!

파이썬 2 , 165146 바이트

• Outgolfer Erik 덕분에 19 바이트를 절약했습니다 .

O=lambda n:n>1and-~O(n/min(d for d in range(2,n+1)if n%d<1))
def f(A,B):L=[int(A[:j]+B+A[j:])for j in range(len(A)+1)];print L.index(min(L,key=O))

온라인으로 사용해보십시오!

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

테스트 사례

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

console.log(f('1234','32'))   // 1
console.log(f('3456','3'))    // 4
console.log(f('378','1824'))  // 0
console.log(f('1824','378'))  // 4
console.log(f('67','267'))    // 1
console.log(f('435','1'))     // 1

J, 60 바이트

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

명백한 dyad. 오른쪽에서 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

파이썬 3, 128 바이트

0- 인덱싱; 문자열을 매개 변수로받습니다. Jonathan Frech 덕분에 -6 바이트

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))

파이썬, 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:])))

실제로 이것은 기본 최대 재귀 깊이를 매우 빠르게 초과합니다.