Dados dois inteiros positivos A e B , retorne a posição p que minimiza o número de fatores primos (contando multiplicidades) do número inteiro resultante, quando B é inserido em A em p .

Por exemplo, dados A = 1234 e B = 32 , essas são as inserções possíveis (com p sendo indexado a 0) e as informações correspondentes sobre seus fatores principais:

p Resultado Fatores primos | Ω (N) / contagem

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

Você pode ver que o resultado possui um número mínimo de fatores primos, 3, quando p é 1. Portanto, nesse caso em particular, você deve gerar 1 .

Especificações

• Se houver várias posições p que minimizem o resultado, você pode optar por imprimir todas elas ou qualquer uma delas.

• Você pode escolher indexação 0 ou indexação 1 para p , mas essa opção deve ser consistente.

• A e B podem ser tomados como números inteiros, seqüências de caracteres ou listas de dígitos.

• Você pode competir em qualquer linguagem de programação e pode receber e fornecer saída por qualquer método padrão , observando que essas brechas são proibidas por padrão. Isso é código-golfe, então a submissão mais curta (pontuada em bytes) vence!

Casos de teste

A, B -> p (indexado 0) / p (indexado 1)

1234, 32 -> 1/2
3456, 3 -> 4/5
378, 1824 -> 0/1
1824, 378 -> 4/5
67, 267 -> Qualquer um ou todos entre: [1, 2] / [2, 3]
435, 1 -> Qualquer um ou todos entre: [1, 2, 3] / [2, 3, 4]
378100, 1878980901 -> Qualquer um ou todos entre: [5, 6] / [6, 7]

Por conveniência, aqui está uma lista de tuplas representando cada par de entradas:

[(1234, 32), (3456, 3), (378, 1824), (1824, 378), (67, 267), (435, 1), (378100, 1878980901)]

Casca , 16 bytes

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

Espera entrada como strings, experimente online!

Explicaçã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 bytes

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

As entradas são seqüências de caracteres na ordem inversa. A saída é baseada em 1. Se houver um empate, a posição mais baixa é exibida.

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Pitão, 20 13 11 bytes

.mlPsXbQzhl

Experimente online

Explicação

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

Gelatina , 21 bytes

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

Experimente online!

-1 graças ao Sr. Xcoder .

Retorna todas as posições possíveis.

Japonês , 22 21 bytes

Isso pareceu muito tempo enquanto eu estava escrevendo, mas, olhando algumas das outras soluções, na verdade parece um pouco competitivo. Ainda assim, provavelmente há um pouco de espaço para melhorias - o cNq)em particular está me irritando. Explicação a seguir.

Pega a primeira entrada como uma string e a segunda como um número inteiro ou uma string. O resultado é indexado em 0 e retornará o primeiro índice se houver várias soluções.

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

Tente

Explicação

      :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 bytes

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

Experimente online!

(Sugestões longas / de golfe são bem-vindas. Também expira o tempo limite no TIO para o último caso de teste, mas o algoritmo deve funcionar nesse caso sem problemas.)

O PowerShell não possui nenhum fator de fatoração principal incorporado, portanto, isso empresta o código da minha resposta no Prime Factors Buddies . Essa é a functiondeclaração da primeira linha .

Tomamos entrada $a,$be, em seguida, definimos $pcomo uma hashtable vazia. Em seguida, pegamos a string $b$a, transformamos em uma matriz singleton com o operador vírgula ,e concatenamos a matriz com as coisas . O material é um loop $a, inserindo $bem todos os pontos, finalmente concatenado com o array $a$b.

Neste ponto, temos uma matriz de $binseridos em todos os pontos $a. Em seguida, enviamos essa matriz por um loop for |%{...}. Cada iteração, inserimos em nosso hashtable na posição $i++a .countde quantos fatores primos fque determinado elemento $_tem.

Por fim, sorta hashtable baseada em values, pega a 0th da mesma e seleciona a Name(ie, a $ido índice). Isso fica no pipeline e a produção está implícita.

05AB1E , 18 bytes

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

Experimente online!

05AB1E , 27 21 bytes

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

Experimente online!

Ele retorna o menor 0 indexado p .

Graças ao @Enigma por -6 bytes!

Explicação

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

Limpo , 165 ... 154 bytes

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

Experimente online!

Python 2 , 165 146 bytes

• Economizou dezenove bytes graças a Erik, o Outgolfer .

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

Experimente online!

JavaScript (ES6), 120 bytes

Aceita entrada como 2 strings. Retorna uma posição indexada em 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

Casos de teste

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 bytes

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

Díade explícita. Pega B à direita, A à esquerda.

Saída indexada em 0.

Pode ser possível melhorar não usando caixas.

Explicação:

  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

Python 3, 128 bytes

Indexado a 0; recebe strings como parâmetros. -6 bytes graças a 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))

Python, 122 bytes

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

Na prática, isso excede a profundidade máxima de recursão padrão rapidamente.