Dati due numeri interi positivi A e B , restituisce la posizione p che minimizza il numero di fattori primi (contando le molteplicità) dell'intero risultante, quando B è inserito in A a p .

Ad esempio, dato A = 1234 e B = 32 , questi sono i possibili inserimenti (con p indicizzato 0) e le informazioni corrispondenti sui loro fattori primi:

p | Risultato | Fattori primi | Ω (N) / Conteggio

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

Puoi vedere che il risultato ha un numero minimo di fattori primi, 3, quando p è 1. Quindi, in questo caso particolare, dovresti produrre 1 .

Specifiche

• Se sono presenti più posizioni p che riducono al minimo il risultato, è possibile scegliere di emetterle tutte o una qualsiasi.

• È possibile scegliere 0-indicizzazione o 1-indicizzazione per p , ma questa scelta deve essere coerente.

• A e B possono essere presi come numeri interi, stringhe o elenchi di cifre.

• Puoi competere in qualsiasi linguaggio di programmazione e puoi prendere input e fornire output attraverso qualsiasi metodo standard , tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Si tratta di code-golf, quindi vince l'invio più breve (segnato in byte)!

Casi test

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

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

Per comodità, ecco un elenco di tuple che rappresentano ogni coppia di input:

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

Buccia , 16 byte

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

Si aspetta input come stringhe, provalo online!

Spiegazione

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

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

Gli input sono stringhe in ordine inverso. L'output è basato su 1. Se c'è un pareggio viene emessa la posizione più bassa.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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 byte

.mlPsXbQzhl

Provalo online

Spiegazione

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

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

Provalo online!

-1 grazie a Mr. Xcoder .

Restituisce tutte le posizioni possibili.

Japt , 22 21 byte

Mi è sembrato troppo lungo mentre lo stavo scrivendo ma, guardando alcune delle altre soluzioni, sembra in realtà un po 'competitivo. Tuttavia, c'è probabilmente un po 'di margine di miglioramento - Il cNq)particolare mi sta dando fastidio. Spiegazione da seguire.

Accetta il primo input come stringa e il secondo come numero intero o stringa. Il risultato è indicizzato 0 e restituirà il primo indice se ci sono più soluzioni.

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

Provalo

Spiegazione

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

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

Provalo online!

(Sembra gradito / suggerimenti per giocare a golf. Anche il timeout su TIO per l'ultimo caso di test, ma l'algoritmo dovrebbe funzionare senza problemi per quel caso.)

PowerShell non ha alcun fattore di fattorizzazione principale incorporato, quindi questo prende in prestito il codice dalla mia risposta su Amici di Prime Factors . Questa è la functiondichiarazione della prima riga .

Prendiamo l'input $a,$be quindi impostiamo $pcome hashtable vuota. Quindi prendiamo la stringa $b$a, la trasformiamo in una matrice singleton con l'operatore virgola ,e la concateniamo con roba . Il materiale è un loop through $a, che si inserisce $bin ogni punto, infine con un array concatenato $a$b.

A questo punto, abbiamo un array di $binserito in ogni punto $a. Quindi inviamo quell'array attraverso un ciclo for |%{...}. Ogni iterazione, inseriamo nella nostra tabella hash alla posizione $i++del .countquanti fattori primi fquel particolare elemento $_ha.

Infine, abbiamo sortla tabella hash basata su values, prendiamo la 0sua e selezioniamo la sua Name(cioè $il'indice). Rimane in cantiere e l'output è implicito.

05AB1E , 18 byte

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

Provalo online!

05AB1E , 27 21 byte

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

Provalo online!

Restituisce il p più basso indicizzato 0 .

Grazie a @Enigma per -6 byte!

Spiegazione

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

Pulito , 165 ... 154 byte

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

Provalo online!

Python 2 , 165 146 byte

• Risparmio diciannove byte grazie 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))

Provalo online!

JavaScript (ES6), 120 byte

Accetta input come 2 stringhe. Restituisce una posizione indicizzata 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

Casi test

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 byte

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

Diade esplicita. Prende B a destra, A a sinistra.

Uscita indicizzata 0.

Potrebbe essere possibile migliorare non utilizzando le caselle.

Spiegazione:

  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 byte

0-indicizzate; accetta le stringhe come parametri. -6 byte grazie 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 byte

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

In pratica, questo supera abbastanza rapidamente la profondità massima di ricorsione predefinita.