Dados dos enteros positivos A y B , devuelve la posición p que minimiza el número de factores primos (contando multiplicidades) del entero resultante, cuando B se inserta en A en p .

Por ejemplo, dados A = 1234 y B = 32 , estas son las posibles inserciones (con p siendo indexado en 0) y la información correspondiente sobre sus factores primos:

p | Resultado | Factores primos | Ω (N) / Cuenta

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

Puede ver que el resultado tiene un número mínimo de factores primos, 3, cuando p es 1. Por lo tanto, en este caso particular, debe generar 1 .

Especificaciones

• Si hay varias posiciones p que minimizan el resultado, puede optar por mostrarlas todas o cualquiera de ellas.

• Puede elegir indexación 0 o indexación 1 para p , pero esta elección debe ser coherente.

• A y B pueden tomarse como enteros, cadenas o listas de dígitos.

• Puede competir en cualquier lenguaje de programación y puede tomar entradas y proporcionar salidas a través de cualquier método estándar , mientras toma nota de que estas lagunas están prohibidas por defecto. Este es el código de golf, por lo que gana la presentación más corta (puntuada en bytes).

Casos de prueba

A, B -> p (índice 0) / p (índice 1)

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

Por conveniencia, aquí hay una lista de tuplas que representan cada par de entradas:

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

Casco , 16 bytes

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

Espera entradas como cadenas, ¡ pruébelo en línea!

Explicación

§◄(ö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<

Las entradas son cadenas en orden inverso. La salida está basada en 1. Si hay un empate, se muestra la posición más baja.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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 bytes

.mlPsXbQzhl

Pruébalo en línea

Explicación

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

Jalea , 21 bytes

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

Pruébalo en línea!

-1 gracias al Sr. Xcoder .

Devuelve todas las posiciones posibles.

Japt , 22 21 bytes

Esto se sintió demasiado tiempo mientras lo escribía, pero, mirando algunas de las otras soluciones, en realidad parece algo competitivo. Aún así, probablemente haya un poco de margen de mejora: cNq)en particular, me está molestando. Explicación a seguir.

Toma la primera entrada como una cadena y la segunda como un entero o una cadena. El resultado está indexado a 0 y devolverá el primer índice si hay varias soluciones.

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

Intentalo

Explicación

      :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

Pruébalo en línea!

(Parece largo / las sugerencias de golf son bienvenidas. También se agota el tiempo de espera en TIO para el último caso de prueba, pero el algoritmo debería funcionar para ese caso sin problemas).

PowerShell no tiene incorporados factores de factorización primarios, por lo que toma prestado el código de mi respuesta en Prime Factors Buddies . Esa es la functiondeclaración de la primera línea .

Tomamos información $a,$by luego la configuramos $pcomo una tabla hash vacía. Luego tomamos la cadena $b$a, la convertimos en una matriz singleton con el operador de coma ,y la concatenamos con cosas . El material es una a través del bucle $a, la inserción $ben cada punto, por último-concatena matriz con $a$b.

En este punto, tenemos una matriz de $binsertada en cada punto $a. Luego enviamos esa matriz a través de un bucle for |%{...}. Cada iteración, insertamos en nuestra tabla hash en la posición $i++del .countde la cantidad de factores primos fese elemento en particular $_tiene.

Finalmente, hacemos sortla tabla hash basada en values, tomamos la 0th de la misma y seleccionamos su Name(es decir, la $idel índice). Eso queda en la tubería y la salida es implícita.

05AB1E , 18 bytes

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

Pruébalo en línea!

05AB1E , 27 21 bytes

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

Pruébalo en línea!

Devuelve la p indexada 0 más baja .

¡Gracias a @Enigma por -6 bytes!

Explicación

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

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

Pruébalo en línea!

Python 2 , 165 146 bytes

• Ahorró diecinueve bytes gracias a Erik the 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))

Pruébalo en línea!

JavaScript (ES6), 120 bytes

Toma entrada como 2 cadenas. Devuelve una posición indexada 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 prueba

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íada explícita. Toma B a la derecha, A a la izquierda.

Salida indexada a 0.

Podría ser posible mejorar al no usar cajas.

Explicación:

  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

0 indexado; toma cadenas como parámetros. -6 bytes gracias 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:])))

En la práctica, esto supera la profundidad de recursión máxima predeterminada con bastante rapidez.