Reemplazar dos por tres

36

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 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
Asistente de trigo
fuente

Respuestas:

63

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}

fuente
10
Hable acerca de la herramienta adecuada para el trabajo ..
Kevin Cruijssen
23
"No voten por soluciones triviales que solo usan una solución simple". Bueno, en este caso: Saber que hay un lenguaje "Fractran" que tiene una sola función que resuelve esta tarea específica es en sí mismo impresionante.
Stewie Griffin
3
Golf de código SO relacionado (pre-PPCG): escriba un intérprete de Fractran .
hobbs
1
@AnderBiguri: Probablemente busque un lenguaje completo de Turing que sea muy simple / fácil de implementar. Fractran es realmente elegante como las lonas de Turing; la mayoría tiene muchos más bordes ásperos, casos especiales o detalles que podrían cambiarse sin hacer una gran diferencia.
3
@AnderBiguri Parece que salió de sus estudios sobre la conjetura de Collatz; demostró que una generalización de Collatz es equivalente a Fractran y que Fractran es completa de Turing, por lo tanto, Collatz generalizada es indecidible.
hobbs
21

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.

xnor
fuente
¡Agradable esta es mi solución exactamente!
Wheat Wizard
@WheatWizard Me también, ¡ajá!
Graviton
18

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.
Dennis
fuente
Esto supera a Jelly por 1 byte simplemente porque la factorización prima es solo un byte aquí :(
HyperNeutrino
55
@HyperNeutrino: También me di cuenta de eso: "¿por qué Dennis usa 05AB1E? Oh, algoritmo idéntico, nombres incorporados más cortos". Así que tuve que ir y buscar un idioma donde pudiera hacerlo en incluso menos bytes, mediante el uso de un conjunto de componentes integrados aún más apropiado.
14

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!

nimi
fuente
3
La versión lambda se puede acortar a odd`until`\x->div(x*3)2.
Ørjan Johansen
2
La versión original también se puede acortar un byte mediante el uso $para reemplazar un par de paréntesis: ¡ Pruébelo en línea!
@ ØrjanJohansen: ¡ah, bien! Gracias.
nimi
@ ais523: ¿Cómo podría haberme perdido ese, gracias!
nimi
2
Creo que olvidó eliminar un par de ()la versión lambda
CAD97
8

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.

ETHproducciones
fuente
2
x*3/2tiene el mismo bytecount
Leaky Nun
1
f=usualmente no es necesario para js.
Christoph
3
@ Christoph Gracias, pero para llamarse a sí f(x*1.5)mismo necesita tener el nombre f, de ahí por qué f=está incluido.
ETHproductions
@ETHproductions Uhm ... ¡por supuesto! Me lo perdí. ¿Hay algún meta sobre cómo se ve exactamente el código de llamada?
Christoph
2
@ Christoph Aquí está la meta publicación relevante.
ETHproductions
8

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

0 '
fuente
> Próximamente ...
Wheat Wizard
7

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

Greg Martin
fuente
¿ x_?EvenQFuncionaría en lugar de x_/;EvenQ@x?
No es un árbol
1
Tienes toda la razón, gracias!
Greg Martin
6

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
Emigna
fuente
2
ÒDÈ+Pdebería guardar un byte
Adnan
@Adnan: ¡Gracias!
Emigna
6

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.
Martin Ender
fuente
1
Tu obsesión se confirma oficialmente.
Leaky Nun
4

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!

Hiperneutrino
fuente
2
Sugerencia: 2 es el único número primo par y el más pequeño.
Dennis
@ Dennis ya veo. Sí, lo tengo ahora. ¡Gracias! :)
HyperNeutrino
Felicitaciones por aprender Jelly.
Leaky Nun
@LeakyNun ¡Gracias! Y gracias por enseñármelo. :)
HyperNeutrino 05 de
¡Felicidades por esta respuesta!
Erik the Outgolfer
4

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

Maria
fuente
Enfoque interesante: lástima que no sea tan corto como la solución Pyth existente.
Esolanging Fruit
@ Challenger5 No veo ninguna otra solución Pyth aquí.
Maria
1
Oh, bien entonces. Es un enfoque más interesante que el típico para este desafío.
Esolanging Fruit
4

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:

Ungolfed

Diseño aproximado de memoria

enter image description here

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
Manfred Radlwimmer
fuente
1
Bienvenido a PPCG! :)
Martin Ender
@MartinEnder Gracias, impresionante lenguaje por cierto. :)
Manfred Radlwimmer el
1
Gracias por usarlo! :) ¿No puede simplificar el diseño de la memoria (y por lo tanto la cantidad de movimiento que necesita hacer) si calcula %2y :2ambos en el borde del "módulo"? (Para que pueda deshacerse de los dos bordes superiores). Y luego, ¿podría unir la rama "multiplicador" en el borde "módulo" en lugar del borde "divisor" para que necesite menos movimiento después de cada rama? (Es posible que incluso pueda rotar esa sección, de modo que "resultado" o "temp 2" toque "módulo", lo que significaría que solo necesita copiar el resultado final una vez antes de poder calcular el producto).
Martin Ender
@MartinEnder Uhhhm probablemente. Todavía estoy aprendiendo la parte de "Agonía" del lenguaje, así que por ahora probablemente me limitaré a hacer la cuadrícula más pequeña sin tocar la lógica ^^
Manfred Radlwimmer el
3

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
Monja permeable
fuente
2

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

Adán
fuente
Pensé que te encontraba [:asqueroso.
Leaky Nun
@LeakyNun, pero no era tan inteligente como Conor O'Brien .
Adám
2

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
Conor O'Brien
fuente
Huh, cambiaste el algoritmo mientras yo escribía el mío. Ahora usamos lo mismo.
Adám
@ Adám Oh, jaja. ¡Buena respuesta! No pude resistir la oportunidad de usar rollaquí. :)
Conor O'Brien
De hecho, podría guardar algunos bytes más ... editar guardado algunos: D
Conor O'Brien
Es curioso que lo llames Roll, yo lo llamo Under. Espero ponerlo en APL pronto.
Adám
@ Adám Jaja en realidad se llama bajo. Confundí los términos
Conor O'Brien
2

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
Monja permeable
fuente
2

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
Luke
fuente
Ja, JS está empatado con Japt. Una señal segura de que hay una solución mucho más corta ;-)
ETHproductions
Sugerencias: ×es un acceso directo para r@X*Y}1(o simplemente r*1), que puede ser útil. También hay XwYcuál es Math.max(X,Y).
ETHproductions
Gracias, aunque la solución recursiva es realmente la más corta.
Lucas
¡Buena esa! Creo que puedes hacer k m_w3Ã×para guardar un byte. Además, m_se puede acortar a ®.
Oliver
2

PHP, 36 bytes

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

Pruébalo en línea!

Jörg Hülsermann
fuente
1
for($a=$argn;!1&$a;)$a*=3/2;echo$a;renombrar $argnguarda un solo byte.
Christoph
2

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
Fruta Esolanging
fuente
2

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.

Jo King
fuente
Maldición, no pensé en eso
Manfred Radlwimmer el
1
@ManfredRadlwimmer No se preocupe, codificar cualquier cosa en Hexagony es un logro en sí mismo
Jo King el
1

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
ETHproducciones
fuente
1

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.

JAD
fuente
1

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)
bwillsh
fuente
17 bytes
Jo King
1

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
Phil H
fuente
0

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
Mego
fuente