Dado un número entero positivo, escriba un código para tomar su factorización prima y reemplazar todos sus factores de 2con 3.

Por ejemplo

12 = 2 * 2 * 3 -> 3 * 3 * 3 = 27

Este es el código de golf, por lo que el objetivo es minimizar el recuento de bytes de su respuesta.

Casos de prueba

1 -> 1
2 -> 3
3 -> 3
4 -> 9
5 -> 5
6 -> 9
7 -> 7
8 -> 27
9 -> 9
10 -> 15
11 -> 11
12 -> 27
13 -> 13
14 -> 21
15 -> 15
16 -> 81
17 -> 17
18 -> 27
19 -> 19
20 -> 45
21 -> 21
22 -> 33
23 -> 23
24 -> 81
25 -> 25
26 -> 39
27 -> 27
28 -> 63
29 -> 29

Fractran , 3 bytes

3/2

Literalmente, Fractran solo tiene un componente incorporado, pero resulta que hace exactamente lo que esta tarea está pidiendo. (También es Turing completo, por sí mismo).

El lenguaje realmente no tiene una sintaxis o intérprete estandarizada. Este intérprete (en un comentario en una publicación de blog, es un lenguaje muy simple) aceptará la sintaxis que se muestra aquí. (Hay otros intérpretes de Fractran con otras sintaxis, por ejemplo, algunos escribirían este programa como3 2 , o incluso3 y 2como argumentos de línea de comando, lo que conduciría a una puntuación de 0 + 3 bytes. Dudo que sea posible hacerlo mejor que 3 en un intérprete preexistente, sin embargo).

Explicación

3/2
 /   Replace a factor of
  2  2
3    with 3
     {implicit: repeat until no more replacements are possible}

Python 2 , 28 bytes

f=lambda n:n%2*n or 3*f(n/2)

Pruébalo en línea!

Divide recursivamente el número por 2 y multiplica el resultado por 3, siempre que el número sea par. Los números impares se devuelven.

32 bytes alt:

lambda n:n*(n&-n)**0.58496250072

Pruébalo en línea . Tiene algún error de flotación. La constante eslog_2(3)-1 .

Usos (n&-n)para encontrar el mayor factor de potencia de 2 n, los conversos 3**kal 2**kelevarlo al poder de log_2(3)-1.

05AB1E , 4 bytes

Ò1~P

Pruébalo en línea!

Cómo funciona

Ò     Compute the prime factorization of the input.
 1~   Perform bitwise OR with 1, making the only even prime (2) odd (3).
   P  Take the product of the result.

Haskell, 24 23 bytes

until odd$(*3).(`div`2)

Divide por dos y multiplica por 3 hasta un truco extraño en Haskell.

Pruébalo en línea!

Alternativa con una función lambda en lugar de una función de punto libre y con el mismo número de bytes:

odd`until`\x->div(x*3)2

Editar: @ ais523 guardó un byte en la versión original y @ Ørjan Johansen en la versión alternativa, por lo que ambas versiones tienen la misma longitud. ¡Gracias!

JavaScript (ES6), 19 bytes

f=x=>x%2?x:f(x*1.5)

Si bien la entrada es divisible por dos, la multiplica por 1.5, lo que equivale a dividir por 2 y multiplicar por 3.

Brain-Flak , 76 bytes

{{({}[()]<([({})]()<({}{})>)>)}{}([{}]()){{}((({})){}{})<>}<>}<>({}({}){}())

Pruébalo en línea!

Explicación

Este programa funciona dividiendo el número entre dos y triplicando hasta obtener el resto de la división. Luego deja de hacer bucles y se duplica y agrega uno al número final.

Una explicación más detallada eventualmente ...

Mathematica, 22 19 bytes

¡Gracias a lanlock4 por guardar 3 bytes!

#//.x_?EvenQ:>3x/2&

Función pura que hace el reemplazo repetidamente, un factor de 2 a la vez. Funciona en todos los enteros positivos menores que 2 ⁶⁵⁵³⁷ .

MATL , 7 , 6 bytes

Yf1Z|p

Pruébalo en línea!

1 byte guardado gracias a la observación genial de Dennis

La mejor manera de explicar esto es mostrar la pila en varios puntos.

Yf  % Prime factors

[2 2 2 3]

1Z| % Bitwise OR with 1

[3 3 3 3]

p   % Product

81

Solución alternativa:

Yfto~+p

05AB1E , 6 5 bytes

Salvó un byte gracias a Adnan .

ÒDÈ+P

Pruébalo en línea!

Explicación

Ò       # push list of prime factors of input
 D      # duplicate
  È     # check each factor for evenness (1 if true, else 0)
   +    # add list of factors and list of comparison results
    P   # product

Alice , 9 bytes

2/S 3
o@i

Pruébalo en línea!

Alice tiene una función incorporada para reemplazar un divisor de un número con otro. No pensé que podría usarlo tan pronto ...

Usando los puntos de código de caracteres para E / S, esto se convierte en 6 bytes: I23SO@ .

Explicación

2   Push 2 (irrelevant).
/   Reflect to SE. Switch to Ordinal.
i   Read all input as a string.
    The IP bounces up and down, hits the bottom right corner and turns around,
    bounces down again.
i   Try to read more input, but we're at EOF so this pushes an empty string.
/   Reflect to W. Switch to Cardinal.
2   Push 2.
    The IP wraps around to the last column.
3   Push 3.
S   Implicitly discard the empty string and convert the input string to the integer
    value it contains. Then replace the divisor 2 with the divisor 3 in the input.
    This works by multiplying the value by 3/2 as long as it's divisible by 2.
/   Reflect to NW. Switch to Ordinal.
    Immediately bounce off the top boundary. Move SW.   
o   Implicitly convert the result to a string and print it.
    Bounce off the bottom left corner. Move NE.
/   Reflect to S. Switch to Cardinal.
@   Terminate the program.

Jalea , 8 5 bytes

Æf3»P

Æf3»P  Main Link, argument is z
Æf     Prime factors
  3»   Takes maximum of 3 and the value for each value in the array
    P  Takes the product of the whole thing

Pruébalo en línea!

-3 bytes gracias a una pista de @Dennis!

Pyth - 14 10 9 bytes

*^1.5/PQ2

Cuenta el número de 2s en la factorización prima (/ PQ2). Multiplica la entrada por 1.5 ^ (# de 2s)

Intentalo

Java , 38 bytes

int f(int n){return n%2>0?n:f(n/2*3);}

Pruébalo en línea!

Solución anterior de 43 bytes:

int f(int n){for(;n%2<1;)n=n/2*3;return n;}

Pruébalo en línea!

Hexagonía , 112 91 bytes

Tamaño de cuadrícula 6 (91 bytes)

      ? { 2 . . <
     / = { * = \ "
    . & . . . { _ '
   . . { . . } ' * 2
  _ } { / . } & . ! "
 . > % . . < | . . @ |
  \ . . \ . | ~ . . 3
   . . " . } . " . "
    . & . \ = & / 1
     \ = { : = } .
      [ = { { { <

Versión compacta

?{2..</={*=\".&...{_'..{..}'*2_}{/.}&.!".>%..<|..@|\..\.|~..3..".}.".".&.\=&/1\={:=}.[={{{<

Tamaño de cuadrícula 7 (112 bytes)

       ? { 2 " ' 2 <
      / { * \ / : \ "
     . = . = . = | . 3
    / & / { . . } { . "
   . > $ } { { } / = . 1
  _ . . } . . _ . . & . {
 . > % < . . ~ & . . " . |
  | . . } - " . ' . @ | {
   . . . = & . . * ! . {
    . . . _ . . . _ . =
     > 1 . . . . . < [
      . . . . . . . .
       . . . . . . .

Pruébalo en línea!

Versión compacta:

?{2"'2</{*\/:\".=.=.=|.3/&/{..}{.".>$}{{}/=.1_..}.._..&.{.>%<..~&..".||..}-".'.@|{...=&..*!.{..._..._.=>1.....<[

Versión sin golf para una mejor legibilidad:

Diseño aproximado de memoria

Ruta gris (inicialización de memoria)

?     Read input as integer (Input)
{     Move to memory edge "Divisor left"
2     Set current memory edge to 2 
" '   Move to memory edge "Divisor right" 
2     Set current memory edge to 2
"     Move to memory edge "Multiplier" 
3     Set current memory edge to 3
"     Move to memory edge "Temp 2" 
1     Set current memory edge to 1 
{ { { Move to memory edge "Modulo"
=     Turn memory pointer around 
[     Continue with next instruction pointer

Entrada de bucle

%     Set "Modulo" to Input mod Divisor
<     Branch depending on result

Green Path (el valor sigue siendo divisible por 2)

} } {     Move to memory edge "Result"
=         Turn memory pointer around 
*         Set "Result" to "Temp 2" times "Multiplier" (3) 
{ = &     Copy "Result" into "Temp2" 
{ { } } = Move to "Temp"
:         Set "Temp" to Input / Divisor (2)
{ = &     Copy "Temp" back to "Input"
"         Move back to "Modulo"

Camino rojo (el valor ya no es divisible por 2)

} = & " ~ & ' Drag what's left of "Input" along to "Multiplier"
*             Multiply "Multiplier" with "Temp 2"
! @           Output result, exit program

Retina , 23 bytes

.+
$*
+`^(1+)\1$
$&$1
1

Pruébalo en línea!

Brachylog , 7 bytes

~×₂×₃↰|

Pruébalo en línea!

Cómo funciona

~×₂×₃↰|      original program
?~×₂×₃↰.|?.  with implicit input (?) and output (.) added

?~×₂         input "un-multiplied" by 2
    ×₃       multiplied by 3
      ↰      recursion
       .     is the output
        |    or (in case the above fails, meaning that the input
                 cannot be "un-multiplied" by 2)
         ?.  the input is the output

J , 11 bytes

[:*/q:+2=q:

Pruébalo en línea!

[: cap (marcador de posición para llamar al siguiente verbo de forma mónada)

*/ el producto de

q: los factores primos

+ plus (es decir, con uno agregado donde)

2 dos

= es igual a (cada uno de)

q: los factores primos

J , 15 12 10 bytes

(+2&=)&.q:

Pruébalo en línea! Funciona de manera similar a la siguiente, solo tiene una lógica diferente con respecto al reemplazo de 2con3 .

15 bytes

(2&={,&3)"+&.q:

Pruébalo en línea!

Explicación

(2&={,&3)"+&.q:
           &.    "under"; applies the verb on the right, then the left,
                 then the inverse of the right
             q:  prime factors
(       )"+      apply inside on each factor
     ,&3         pair with three: [factor, 3]
 2&=             equality with two: factor == 2
    {            list selection: [factor, 3][factor == 2]
                 gives us 3 for 2 and factor for anything else
           &.q:  under prime factor

Pyth , 9 bytes

Salida entera \ o /

*F+1.|R1P

Banco de pruebas .

Cómo funciona

*F+1.|R1P
        P   prime factorization
    .|R1    bitwise OR each element with 1
*F+1        product

Japt , 19 16 10 9 7 bytes

k ®w3Ã×

Pruébalo en línea!

Explicación

 k ®   w3Ã ×
Uk mZ{Zw3} r*1
U              # (input)
 k m           # for every prime factor
    Z{Zw3}     # replace it by the maximum of itself and 3
           r*1 # output the product

PHP, 36 bytes

for($a=$argn;$a%2<1;)$a*=3/2;echo$a;

Pruébalo en línea!

CJam, 10 9 bytes

rimf1f|:*

Muy simple

Explicación:

ri  e# Read integer:         | 28
mf  e# Prime factors:        | [2 2 7]
1   e# Push 1:               | [2 2 7] 1
f|  e# Bitwise OR with each: | [3 3 7]
:*  e# Product:              | 63

Hexagonía , 28 27 26 bytes

?'2{{(\}}>='!:@=$\%<..>)"*

Pruébalo en línea!

Dispuesto:

    ? ' 2 {
   { ( \ } }
  > = ' ! : @
 = $ \ % < . .
  > ) " * . .
   . . . . .
    . . . .

Esto básicamente se ejecuta:

num = input()
while num%2 == 0:
    num = (num/2)*3
print num

En este punto, es un ejercicio sobre cuán tortuoso puedo obtener la ruta del bucle para minimizar los bytes.

Japt , 7 bytes

k mw3 ×

Pruébalo en línea!

Explicación

k mw3 ×

k        // Factorize the input.
  mw3    // Map each item X by taking max(X, 3).
      ×  // Take the product of the resulting array.
         // Implicit: output result of last expression

APL (Dyalog Unicode) , 26 bytes

{⍵(⊣×(3*⊢)×(÷2*⊢))2⍟⍵∨2*⍵}

Pruébalo en línea!

Esto es demasiado detallado, debo estar haciendo algo mal ...

R, 42 bytes

La única cantidad correcta de bytes en una respuesta.

x=gmp::factorize(scan());x[x==2]=3;prod(x)

Bastante sencillo, usa el gmppaquete para factorizar x, reemplaza 2s por 3s y devuelve el producto.

Befunge-93 , 20 bytes

&>:2%!#v_.@
 ^*3/2 <

Pruébalo en línea!

& - take in input and add it to the stack
> - move right
: - duplicate the top of the stack
2 - add two to the stack
% - pop 2 and the input off the stack and put input%2 on the stack
! - logical not the top of the stack
# - jump over the next command
_ - horizontal if, if the top of the stack is 0 (i.e. input%2 was non zero) go 
    right, else go left

If Zero:
. - output the top of the stack
@ - end code

If Not Zero:
v - move down
< - move left
2 - add 2 the top of the stack
/ - pop top two, add var/2 to the stack
3 - add 3 to stack
* - pop top two, add var*3 to the stack
^ - move up
> - move right (and start to loop)

Perl 6 , 14 bytes

{1.5**.lsb*$_}

lsb devuelve la posición del bit menos significativo, contado desde la derecha. Es decir, cuántos ceros finales en la representación binaria, que es el mismo que el número de factores de 2. Entonces eleva 3/2 a esa potencia y listo.

say {$_*1.5**.lsb}(24);
> 81

Pyke , 5 bytes

P1.|B

Pruébalo en línea!

En realidad , 9 bytes

w⌠i1|ⁿ⌡Mπ

Pruébalo en línea!

Explicación:

w⌠i1|ⁿ⌡Mπ
w          factor into [prime, exponent] pairs
 ⌠i1|ⁿ⌡M   for each pair:
  i          flatten
   1|        prime | 1 (bitwise OR)
     ⁿ       raise to exponent
        π  product