Gegeben seien zwei positive ganze Zahlen A und B , Rückkehr der Position p das minimiert die Anzahl von Primfaktoren (Zählen Multiplizitäten) der resultierenden ganze Zahl ist , wenn B ist eingefügt in A bei p .

Bei A = 1234 und B = 32 sind dies beispielsweise die möglichen Einfügungen (wobei p mit 0 indiziert ist) und die entsprechenden Informationen zu ihren Primfaktoren:

p | Ergebnis | Primfaktoren | Ω (N) / Anzahl

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

Sie können sehen, dass das Ergebnis eine minimale Anzahl von Primfaktoren hat, 3, wenn p 1 ist. In diesem speziellen Fall sollten Sie also 1 ausgeben .

Technische Daten

• Wenn es mehrere Positionen p gibt , die das Ergebnis minimieren, können Sie alle oder nur eine davon ausgeben.

• Sie können 0-Indizierung oder 1-Indizierung für p wählen , aber diese Auswahl muss konsistent sein.

• A und B können als ganze Zahlen, Zeichenfolgen oder Ziffernlisten verwendet werden.

• Sie können in jeder Programmiersprache antreten und über jede Standardmethode Eingaben und Ausgaben vornehmen. Beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind. Das ist Code-Golf, also gewinnt die kürzeste Einsendung (in Bytes)!

Testfälle

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

1234, 32 -> 1/2
3456, 3 -> 4/5
378, 1824 -> 0/1
1824, 378 -> 4/5
67, 267 -> Irgendwelche oder alle unter: [1, 2] / [2, 3]
435, 1 -> Beliebige oder alle unter: [1, 2, 3] / [2, 3, 4]
378100, 1878980901 -> Beliebige oder alle unter: [5, 6] / [6, 7]

Der Einfachheit halber finden Sie hier eine Liste von Tupeln, die jedes Eingangspaar darstellen:

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

Schale , 16 Bytes

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

Erwarten Sie die Eingabe als Zeichenfolge, versuchen Sie es online!

Erläuterung

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

Eingaben sind Zeichenfolgen in umgekehrter Reihenfolge. Die Ausgabe ist 1-basiert. Bei Gleichstand wird die niedrigste Position ausgegeben.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Probieren Sie es online aus

Erläuterung

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

Jelly , 21 Bytes

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

Probieren Sie es online!

-1 Danke an Herrn Xcoder .

Gibt alle möglichen Positionen zurück.

Japt , 22 21 Bytes

Das fühlte sich viel zu lange an, als ich es geschrieben habe, aber wenn man sich einige der anderen Lösungen ansieht, scheint es tatsächlich etwas wettbewerbsfähig zu sein. Trotzdem gibt es wahrscheinlich ein bisschen Raum für Verbesserungen -cNq) nervt mich besonders. Erklärung folgt.

Übernimmt die erste Eingabe als Zeichenfolge und die zweite entweder als Ganzzahl oder als Zeichenfolge. Das Ergebnis ist 0-indiziert und gibt den ersten Index zurück, wenn mehrere Lösungen vorhanden sind.

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

Versuch es

Erläuterung

      :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

Probieren Sie es online!

(Scheint lang / Golf Vorschläge willkommen. Auch Timeout auf TIO für den letzten Testfall, aber der Algorithmus sollte für diesen Fall ohne Probleme funktionieren.)

PowerShell verfügt über keine eingebauten Primfaktor-Funktionen. Daher ist dieser Code aus meiner Antwort auf Prime Factors Buddies entlehnt . Das ist die erste Zeilefunction Erklärung .

Wir nehmen Eingaben $a,$bund setzen $psie dann als leere Hashtabelle. Als nächstes nehmen wir den String $b$a, wandeln ihn mit dem Komma-Operator in ein Singleton-Array um ,und verknüpfen das Array mit Dingen . Das Zeug ist eine Schleife $a, die $ban jeder Stelle eingefügt und schließlich mit einem Array verkettet wird $a$b.

Zu diesem Zeitpunkt haben wir $ban jedem Punkt in ein Array von eingefügt $a. Wir senden dieses Array dann durch eine for-Schleife |%{...}. Bei jeder Iteration fügen wir in unsere Hash-Tabelle $i++die Anzahl der .countPrimfaktoren ein, fdie ein bestimmtes Element aufweist $_.

Schließlich nehmen wir sortdie Hash-Tabelle, die auf values basiert 0, und wählen ihre Name(dh die $ides Index) aus. Das bleibt in der Pipeline und die Ausgabe ist implizit.

05AB1E , 18 Bytes

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

Probieren Sie es online!

05AB1E , 27 21 Bytes

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

Probieren Sie es online!

Es gibt das niedrigste 0-indizierte p zurück .

Danke an @Enigma für -6 Bytes!

Erläuterung

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

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

Probieren Sie es online!

Python 2 , 165 146 Bytes

• Dank Erik the Outgolfer neunzehn Bytes gespeichert .

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

Probieren Sie es online!

JavaScript (ES6), 120 Byte

Nimmt die Eingabe als 2 Zeichenfolgen. Gibt eine 0-indizierte Position zurück.

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

Testfälle

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'

Explizite Dyade. Nimmt B rechts, A links.

0-indizierte Ausgabe.

Könnte sich verbessern, wenn keine Boxen verwendet werden.

Erläuterung:

  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-indiziert; nimmt Zeichenfolgen als Parameter auf. -6 Bytes dank 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:])))

In der Praxis überschreitet dies ziemlich schnell die voreingestellte maximale Rekursionstiefe.