Sostituisci due con tre

36

Dato un numero intero positivo n scrivi del codice per prendere la sua scomposizione in fattori primi e sostituire tutti i suoi fattori 2con 3.

Per esempio

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

Si tratta di code-golf, quindi l'obiettivo è ridurre al minimo il numero di byte della risposta.

Casi test

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
code-golf  arithmetic  number-theory 
— Mago del grano
fonte

Risposte:

63

Fractran , 3 byte

3/2

Fractran ha letteralmente un solo elemento incorporato, ma capita esattamente di fare ciò che questo compito richiede. (È anche completo di Turing, da solo.)

La lingua in realtà non ha una sintassi o un interprete standardizzata. Questo interprete (in un commento a un post sul blog - è un linguaggio molto semplice) accetterà la sintassi mostrata qui. (Esistono altri interpreti di Fractran con altre sintassi, ad esempio alcuni scriverebbero questo programma come 3 2, o addirittura usando 3e 2come argomenti della riga di comando, il che porterebbe a un punteggio di 0 + 3 byte. Dubito che sia possibile fare meglio di 3 in un interprete preesistente, però.)

Spiegazione

3/2
 /   Replace a factor of
  2  2
3    with 3
     {implicit: repeat until no more replacements are possible}
10
Parla dello strumento giusto per il lavoro ..
— Kevin Cruijssen,
23
"Non votare soluzioni banali che utilizzano solo un semplice built-in." Bene, in questo caso: sapere che esiste un linguaggio "Fractran" che ha un unico built-in che risolve questo compito specifico è di per sé impressionante.
— Stewie Griffin,
3
Golf del codice SO correlato (pre-PPCG): scrivere un interprete Fractran .
— Hobbs,
1
@AnderBiguri: è probabile che cerchi un linguaggio completo di Turing che sia molto semplice / facile da implementare. Fractran è davvero elegante come vanno i teloni di Turing; la maggior parte ha bordi molto più ruvidi, casi speciali o dettagli che potrebbero essere modificati senza fare una grande differenza.
3
@AnderBiguri Sembra uscito dai suoi studi sulla congettura di Collatz; ha dimostrato che una generalizzazione di Collatz equivale a Fractran e che Fractran è Turing-complete, quindi Collatz generalizzato è indecidibile.
— Hobbs,
21

Python 2 , 28 byte

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

Provalo online!

Dividi in modo ricorsivo il numero per 2 e moltiplica il risultato per 3, purché il numero sia pari. I numeri dispari si restituiscono.

32 byte alt:

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

Provalo online . Ha qualche errore float. La costante è log_2(3)-1.

Usa (n&-n)per trovare il più grande fattore di potenza di 2 di n, i convertiti 3**kin 2**kelevandolo al potere di log_2(3)-1.

— XNOR
fonte
Bella questa è esattamente la mia soluzione!
— Wheat Wizard
@WheatWizard Anche io, aha!
— Graviton,
18

05AB1E , 4 byte

Ò1~P

Provalo online!

Come funziona

Ò     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
fonte
Questo batte Jelly di 1 byte semplicemente perché la scomposizione in
— fattori
5
@HyperNeutrino: ho notato anche questo: "perché Dennis sta usando 05AB1E? Oh, algoritmo identico, nomi incorporati più brevi". Quindi sono dovuto andare a trovare una lingua in cui potrei farlo in ancora meno byte, tramite l'uso di un set di builtin ancora più appropriato.
14

Haskell, 24 23 byte

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

Dividi per due e moltiplica per 3 fino allo strano trucco di Haskell.

Provalo online!

Alternativa con una lambda invece di una funzione pointfree e con lo stesso numero di byte:

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

Modifica: @ ais523 ha salvato un byte nella versione originale e @ Ørjan Johansen uno nella versione alternativa, quindi entrambe le versioni hanno ancora la stessa lunghezza. Grazie!

— Nome del modello
fonte
3
La versione lambda può essere abbreviata in odd`until`\x->div(x*3)2.
— Ørjan Johansen,
2
La versione originale può anche essere accorciata di un byte usando $per sostituire una coppia di parentesi: provala online!
@ ØrjanJohansen: ah, bello! Grazie.
— nimi,
@ ais523: come potrei essermelo perso, grazie!
— nimi,
2
Penso che hai dimenticato di rimuovere un paio ()dalla versione lambda
— CAD97
8

JavaScript (ES6), 19 byte

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

Mentre l'input è divisibile per due, lo moltiplica per 1,5, il che equivale a dividere per 2 e moltiplicare per 3.

— ETHproductions
fonte
2
x*3/2ha lo stesso numero di addetti
— Leaky Nun
1
f=di solito non è necessario per js.
— Christoph,
3
@Christoph Grazie, ma per chiamarsi f(x*1.5)deve avere il nome f, quindi perché f=è incluso.
— ETHproductions
@ETHproductions Uhm ... ovviamente! Ho perso questo. C'è qualche meta su come appare esattamente il codice chiamante?
— Christoph,
2
@Christoph Ecco il meta post rilevante.
— ETHproductions
8

Brain-Flak , 76 byte

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

Provalo online!

Spiegazione

Questo programma funziona dividendo il numero per due e triplicando fino a ottenere un resto di uno dalla divisione. Quindi interrompe il looping e raddoppia e ne aggiunge uno al numero finale.

Spiegazione più dettagliata alla fine ...

— 0 '
fonte
> Prossimamente ...
— Mago del grano,
7

Mathematica, 22 19 byte

Grazie a lanlock4 per aver salvato 3 byte!

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

Funzione pura che esegue ripetutamente la sostituzione, un fattore 2 alla volta. Funziona su tutti i numeri interi positivi inferiori a 2 65537 .

— Greg Martin
fonte
Funzionerebbe x_?EvenQinvece di x_/;EvenQ@x?
— Non un albero
1
Hai perfettamente ragione, grazie!
— Greg Martin,
6

05AB1E , 6 5 byte

Salvato un byte grazie ad Adnan .

ÒDÈ+P

Provalo online!

Spiegazione

Ò       # 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
fonte
2
ÒDÈ+Pdovrebbe salvare un byte
— Adnan
@Adnan: grazie!
— Emigna,
6

Alice , 9 byte

2/S 3
o@i

Provalo online!

Alice ha un built-in per sostituire un divisore di un numero con un altro. Non pensavo che avrei potuto usarlo così presto ...

Utilizzando i punti di codice di caratteri per I / O, questo diventa 6 byte: I23SO@.

Spiegazione

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
fonte
1
La tua ossessione è ufficialmente confermata.
— Leaky Nun,
4

Gelatina , 8 5 byte

Æ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

Provalo online!

-3 byte grazie a un suggerimento di @Dennis!

— HyperNeutrino
fonte
2
Suggerimento: 2 è il solo numero primo pari e il più piccolo.
— Dennis,
@Dennis, vedo. Sì, capito adesso. Grazie! :)
— HyperNeutrino,
Congratulazioni per aver imparato Jelly.
— Leaky Nun,
@LeakyNun Grazie! E grazie per avermelo insegnato. :)
— HyperNeutrino
Complimenti per questa risposta!
— Erik the Outgolfer,
4

Pyth - 14 10 9 byte

*^1.5/PQ2

Conta il numero di 2s nella scomposizione in fattori primi (/ PQ2). Moltiplica l'input per 1,5 ^ (N. di 2 secondi)

Provalo

— Maria
fonte
Approccio interessante - peccato che non sia breve come la soluzione Pyth esistente.
— Esolanging Fruit
@ Challenger5 Non vedo nessun'altra soluzione Pyth qui.
— Maria,
1
Oh, ok allora. È un approccio più interessante di quello tipico per questa sfida.
— Esolanging Fruit
4

Esagonia , 112 91 byte

Dimensione griglia 6 (91 byte)

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

Versione compatta

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

Dimensione griglia 7 (112 byte)

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

Provalo online!

Versione compatta:

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

Versione Ungolfed per una migliore leggibilità:

Ungolfed

Layout di memoria approssimativo

inserisci qui la descrizione dell'immagine

Percorso grigio (inizializzazione 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

Voce loop

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

Percorso verde (il valore è ancora divisibile per 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"

Percorso rosso (il valore non è più divisibile per 2)

} = & " ~ & ' Drag what's left of "Input" along to "Multiplier"
*             Multiply "Multiplier" with "Temp 2"
! @           Output result, exit program
— Manfred Radlwimmer
fonte
1
Benvenuti in PPCG! :)
— Martin Ender,
@MartinEnder Grazie, fantastico linguaggio tra noi. :)
— Manfred Radlwimmer il
1
Grazie per averlo usato! :) Non puoi semplificare il layout della memoria (e quindi la quantità di movimento che devi fare) se esegui il calcolo %2ed :2entrambi nel bordo del "modulo"? (Quindi puoi semplicemente sbarazzarti dei due bordi superiori.) E poi, potresti attaccare il ramo "moltiplicatore" sul bordo "modulo" invece del bordo "divisore" in modo da avere meno movimento dopo ogni ramo? (Potresti anche ruotare quella sezione, in modo che "risultato" o "temp 2" tocchi "modulo", il che significherebbe che devi copiare il risultato finale solo una volta prima di poter calcolare il prodotto.)
— Martin Ender
@MartinEnder Uhhhm probabilmente. Sto ancora aggirando la parte "Agonia" della lingua, quindi per ora probabilmente mi limiterò a
— ridurre
3

Brachylog , 7 byte

~×₂×₃↰|

Provalo online!

Come funziona

~×₂×₃↰|      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
— Perdente Suora
fonte
2

J , 11 byte

[:*/q:+2=q:

Provalo online!

[: cap (segnaposto per chiamare il verbo successivo in modo monadico)

*/ il prodotto di

q: i fattori primi

+ più (cioè con uno aggiunto dove)

2 Due

= è uguale a (ciascuno di)

q: i fattori primi

— Adamo
fonte
Pensavo fossi [:disgustoso.
— Leaky Nun,
@LeakyNun, ma non ero intelligente come Conor O'Brien .
— Adám,
2

J , 15 12 10 byte

(+2&=)&.q:

Provalo online! Funziona in modo simile al seguente, ha solo una logica diversa per quanto riguarda la sostituzione di 2con 3.

15 byte

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

Provalo online!

Spiegazione

(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
fonte
Ehi, hai cambiato algoritmo mentre stavo scrivendo il mio. Ora usiamo lo stesso.
— Adám,
@ Adám Oh, ahah. Bella risposta! Non ho potuto resistere all'opportunità di usare rollqui. :)
— Conor O'Brien,
In realtà potrei essere in grado di salvare qualche altro byte ... modifica salvato alcuni: D
— Conor O'Brien
Divertente lo chiami Roll, io lo chiamo Under. Spero di farlo presto in APL.
— Adám,
@ Adám Haha si chiama in realtà sotto. Ho confuso i termini
— Conor O'Brien
2

Japt , 19 16 10 9 7 byte

k ®w3Ã×

Provalo online!

Spiegazione

 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
— Luca
fonte
Hah, JS è legato con Japt. Un segno sicuro c'è una soluzione molto più breve ;-)
— ETHproductions
Suggerimenti: ×è una scorciatoia per r@X*Y}1(o solo r*1), che potrebbe tornare utile. C'è anche quello XwYche è Math.max(X,Y).
— ETHproductions
Grazie, sebbene la soluzione ricorsiva sia davvero la più breve.
— Luca,
Ben fatto! Penso che tu possa fare k m_w3Ã×per salvare un byte. Inoltre, m_può essere abbreviato in ®.
— Oliver,
2

CJam, 10 9 byte

rimf1f|:*

Davvero semplice.

Spiegazione:

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
— Esolanging Fruit
fonte
2

Esagonia , 28 27 26 byte

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

Provalo online!

Disposte:

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

Questo in pratica funziona:

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

A questo punto è un esercizio su quanto tortuoso posso ottenere il percorso del loop per ridurre al minimo i byte.

— Jo King
fonte
Beh, dannazione, non ci avevo pensato
— Manfred Radlwimmer il
1
@ManfredRadlwimmer Non preoccuparti, scrivere codice in Hexagony è un risultato in sé
— Jo King
1

Japt , 7 byte

k mw3 ×

Provalo online!

Spiegazione

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
— ETHproductions
fonte
1

R, 42 byte

L'unica giusta quantità di byte in una risposta.

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

Abbastanza semplice, usa il gmppacchetto per fattorizzare x, sostituisce 2s per 3s e restituisce il prodotto.

— JAD
fonte
1

Befunge-93 , 20 byte

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

Provalo online!

& - 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
fonte
— Jo King,
1

Perl 6 , 14 byte

{1.5**.lsb*$_}

lsb restituisce la posizione del bit meno significativo, contato da destra. Cioè, quanti zero finali nella rappresentazione binaria, che è lo stesso del numero di fattori di 2. Quindi aumenta 3/2 a quel potere e il gioco è fatto.

say {$_*1.5**.lsb}(24);
> 81
— Phil H
fonte
0

In realtà , 9 byte

w⌠i1|ⁿ⌡Mπ

Provalo online!

Spiegazione:

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.