Fatores primários palíndricos

15

Os problemas primários palíndricos são bastante comuns, mas não é sobre isso que se trata. Nesse desafio, o número não precisa ser um palíndromo, seus principais fatores, sim.

Tarefa

Seu código deve receber um único número inteiro positivo como entrada. Em seguida, verifique se alguma das permutações dos fatores primos desse número inteiro é palíndrica quando concatenada. Nesse caso, imprima um deles (a lista de fatores, não a sequência concatenada). Senão, você deve produzir -1.

Isso é , então o código mais curto em bytes vence!

Casos de teste

11 -> [11]
4 -> [2, 2]
39 -> [3, 13]
6 -> -1
1207 -> [17, 71]
393 -> -1
2352 -> [2, 2, 7, 3, 7, 2, 2]
Maltysen
fonte
1
Outros valores distinguíveis podem -1ser retornados? No Perl 6 eu estou pensando sobre Nil, Failou outros valores indefinidos. A saída também pode ter algum valor posicional?
Brad Gilbert b2gills
List, Array, Seq, Range, Buf, Slip são todos valores posicionais. Ou seja, eles cumprem o papel posicional.
Brad Gilbert b2gills
Então .. devemos exibir uma lista vazia para 1, ou -1?
Jo rei
-1 como elemento é diferente de uma matriz que contêm apenas -1
RosLuP

Respostas:

4

05AB1E , 7 bytes

Òœ.ΔJÂQ

Experimente online!

Explicação:

Ò            # prime factorization of the input
 œ           # permutations
  .Δ         # find the first one such that
    J        # concatenated
     ÂQ      # is a palindrome

(o padrão é convenientemente -1, portanto, não é necessário trabalho extra)

Grimmy
fonte
3

Pitão, 14 bytes

-2 bytes por @FryAmTheEggman

h+f_IjkT.pPQ_1

Explicação:

h                 first element of
 +                (append a -1 to the end in case the filter is empty)
  f                 filter by lambda T:
   _I                 is invariant under reversing
     jkT              stringified list
   .p                over permutations of
     P Q             prime factors of Q with duplicates
  _1              -1

Obrigado @FryAmTheEggman por me lembrar I. Acho que não o usei antes.

Suíte de teste

lirtosiast
fonte
jké o mesmo ques`M
Maltysen
3

CJam - 17 bytes

Obrigado a Martin Büttner por me salvar 10 bytes!

Wqimfe!{s_W%=}=p;

Minha primeira vez escrevendo em CJam! Explicação:

W              # Push a -1 onto the stack
q               # Get input
i               # Convert to integer
mf              # Find prime factorization
e!              # Find all permutations
{...}=          # Find permutation which...
s               # Convert to string
_               # Copy string
W%              # Get inverse
=               # Check if inverse == original
p;              # Print top of stack and discard the rest
KoreanwGlasses
fonte
3
Você pode reverter uma string (ou matriz) com W%. Você também pode usar =com um bloco para obter a primeira fatoração primordial palindrômica. Isso equivale a 18 bytes: Wrimfe!{s_W%=}=p];... você pode salvar mais um terminando com um erro (desde que a saída do erro vá para STDERR):Wrimfe!{s_W%=}=p;
Martin Ender
3
@ MartinBüttner É por isso que eu amo o PPCG. Todo mundo é tão prestativo e amigável!
precisa saber é o seguinte
2

Ruby, 89 + 7 = 96 102 + 7 = 109

->n{n.prime_division.flat_map{|*a,b|a*b}.permutation.find{|x|x.join==x.join.reverse}||-1}

+7 para a -rprimebandeira.

Suspiro , alguns built-in Ruby têm nomes tão longos ... pelo menos isso torna o código bastante auto-explicativo.

O flat_mapbit é porque prime_divisionretorna ex. [[2, 2], [3, 1]]para entrada 12(que representa ).2231

Obrigado a @histocrat por 13 bytes!

Maçaneta da porta
fonte
@histocrat Isso foi um erro da parte do OP (veja os comentários sobre a pergunta). Obrigado, esse é um truque legal com o splat.
Maçaneta
2

Julia, 132 122 bytes

n->(x=filter(p->(q=join(p))==reverse(q),permutations(foldl(vcat,[[repeated(k,v)...]for(k,v)=factor(n)]))))==[]?-1:first(x)

Essa é uma função lambda que aceita um número inteiro e retorna uma matriz ou -1. Para chamá-lo, atribua-o a uma variável.

Ungolfed:

function f(n::Int)
    # Construct an array of all prime factors of n
    P = foldl(vcat, [[repeated(k, v)...] for (k, v) in factor(n)])

    # Filter the set of permutations of this array to only
    # those such that the string constructed by concatenating
    # all elements is a palindrome
    x = filter(p -> (q = join(p)) == reverse(q), P)

    # If x is empty, return -1, otherwise get the first array
    # in the collection
    return x == [] ? -1 : first(x)
end

Economizou 10 bytes graças a Glen O!

Alex A.
fonte
À primeira vista, vejo algumas maneiras de melhorar isso (apenas com base no golfe básico). Use em foldlvez de reduce(eles fazem a mesma coisa, mas foldldefiniram a ordem e são um byte mais curto). Use uma comparação direta com uma estrutura vazia em vez de isempty(não tenho 100% de certeza de que tipo xé, mas se for um conjunto, por exemplo, use x==[]). E use (q=join(p))e depois apenas qno filtro para salvar mais dois bytes.
Glen O
Além disso, eu poderia estar enganado, mas se xfor uma matriz, em vez de first(x)apenas usar x[].
Glen O
@GlenO Muito obrigado como sempre! Eu tentei inicialmente ==[]e estava me dando erros, mas tentei novamente agora e está funcionando. Eu devo ter estragado alguma coisa antes. ¯ \ _ (ツ) _ / ¯ A única sugestão que eu não poderia usar é se livrar first; neste caso, eu tenho que usar firstporque xé um iterador / coleção / algo que não foi getindexdefinido.
Alex A.
2

Braquilog , 10 bytes

ḋp.cX↔X∨_1

Experimente online!

  .           The output is
 p            a permutation of
ḋ             the prime factorization of
              the input
   c          such that concatenated
    X         it is the variable X
     ↔        which reversed
      X       is still X;
       ∨      if this is not possible,
              the output is
        _1    -1.

Inicialmente, eu esperava que ter que produzir em -1vez de ter permissão para falhar teria um custo de bytes bastante grande, mas como a saída no caso de sucesso não pode ser concatenada, custa apenas os dois bytes necessários para escrever _1(se se os removêssemos, deixaria a saída sem restrições por padrão e 0, se alterássemos adicionalmente para , o predicado falharia), porque precisamos quebrar a unificação com a saída implícita de qualquer maneira. (Se a concatenação fosse a saída para o sucesso, mas -1ainda assim fosse a falha, teríamos ḋpc.↔|∧_1ou ḋpc.↔.∨_1. No menor caso, em que a saída é concatenada e o predicado pode falhar, a coisa toda é de apenas cinco bytes:ḋpc.↔. Apesar de não apresentar os fatores reais, é mais uma sensação de ...)

String não relacionada
fonte
1

Haskell, 122 bytes

import Data.Numbers.Primes
import Data.List
f x=head$[p|p<-permutations$primeFactors x,s<-[show=<<p],s==reverse s]++[[-1]]

Exemplo de uso: f 39-> [3,13].

A abordagem óbvia da força bruta. Iterando todas as permutações dos fatores primos e verifique os palíndromos. Escolha o primeiro. Se não houver, a lista está vazia e o anexo é adicionado [-1].

nimi
fonte
1

Perl 6 , 100 bytes

{$/=$_;map(->\f{|({$/%f||($//=f)&&f}...^*!==f)},2..$_).permutations.first({.join.flip eq.join})||-1}
{
  # store copy of argument in $/
  $/ = $_;
  # uses $/ so that I don't have to declare a variable

  # find the prime factors
  map(
    ->\f{
      # Slip so that outer list of all prime factors is flat
      |(
        {
          $/ % f    # return modulus
          ||        # or
          ($/ /= f) # factor the prime out of $/
          &&        # and
          f         # return factor
        }
        # produce a list of them and
        # stop when it returns something other than the factor
        # also ignoring the last non-factor value
        ...^ * !== f
      )
    },
    # find the factors out of the values from 2
    # up to the original argument
    2..$_
    # don't need to skip the non-primes as their
    # prime factorization will have already be
    # factored out of $/
  )

  # try all permutations of the prime factors
  .permutations

  # find the first palindromic one
  .first({ .join.flip eq .join })

  # return -1 if .first returned Nil or empty list
  || -1
}

Uso:

# give it a lexical name
my &prime-palindrome = {...}

say prime-palindrome    1; # -1
say prime-palindrome    2; # (2)
say prime-palindrome   11; # (11)
say prime-palindrome   13; # -1
say prime-palindrome   39; # (3 13)
say prime-palindrome   93; # (31 3)
say prime-palindrome    6; # -1
say prime-palindrome 1207; # (17 71)
say prime-palindrome  393; # -1
say prime-palindrome 2352; # (2 2 7 3 7 2 2)
say prime-palindrome 2351; # -1
say prime-palindrome 2350; # -1

Cerca da metade (53 bytes) é utilizada com o código de fatoração principal.

$/=$_;map(->\f{|({$/%f||($//=f)&&f}...^*!= f)},2..$_)

Se houvesse um prime-factorizemétodo, tudo poderia ser significativamente menor.

{.prime-factorize.permutations.first({.join.flip eq.join})||-1} # 63
Brad Gilbert b2gills
fonte
Uma seção mais curta do código de fator principal pode ser$!=$_;({+$!/($!/=1+(2...$!%%*))}...{2>$!})
Jo King
1

Gelatina , 16 bytes

ÆFŒṙŒ!VŒḂ$ƇḢ¹-¹?

Mais do que eu esperava, tanto na contagem de bytes quanto no tempo necessário para escrever.

Experimente online!

Explicação:

ÆFŒṙŒ!VŒḂ$ƇḢ¹-¹?
ÆFŒṙ                Get the prime factors (gets them as exponents then run-length decodes).
    Œ!              Get the permutations.
          Ƈ         Filter (keep) the ones that...
       ŒḂ$          ...are palindromic when...
      V             ...joined.
           Ḣ        Take the first.
              ¹?    If the value is truthy...
            ¹       ...return the value...
             -      else return -1.
Camarada SparklePony
fonte
1

Japonês -F-1 , 9 bytes

k á æ_¬êS

Tente

Oliver
fonte
O seu link não é ok neste telefone janela ...
RosLuP
@RosLuP O intérprete ainda é relativamente novo. Vou dar um ping em Shaggy, o criador. Aqui está uma TIO ligação
Oliver
1
@RosLuP, qual navegador você está usando?
Shaggy
Internet Explorer para Windows Phone 8.1: (celular) algo que está desaparecendo, possivelmente, é melhor eu usar a minha marca novo telefone Android ou o navegador do Windows 10 (Edge parece que eles chamam)
RosLuP
0

Japonês, 18 bytes

Quase tão curto quanto CJam ...

Uk á f_¬¥Z¬w} g ªJ

Experimente online!

Como funciona

        // Implicit: U = input, e.g. 2352
Uk      // Factorize the input.      [2,2,2,2,3,7,7]
á       // Take permutations.        [[2,2,2,2,3,7,7],[2,2,2,2,7,3,7],[2,2,2,7,2,3,7],...]
f_   }  // Filter to only the ones that return truthily to this function:
Z¬¥Z¬w  //  Return Z.join('') == Z.join('').reverse().
        //                           [[2,2,7,3,7,2,2],[2,7,2,3,2,7,2],[7,2,2,3,2,2,7]]
g       // Take the first item.      [2,2,7,3,7,2,2]
ªJ      // If falsy, resort to -1.   [2,2,7,3,7,2,2]
ETHproductions
fonte
0

JavaScript (ES6), 256 244 208 187 bytes

Guardado 36 bytes graças a @Neil

x=>eval("for(a=[],i=2;x>1;x%i?i++:(a.push(i),x/=i));p=-1,f=(z,t=[])=>z[0]?z.map((u,i)=>f([...z.slice(0,i),...z.slice(i+1)],[...t,u])):(y=t.join``)==[...y].reverse().join``&&(p=t),f(a),p")

Define uma função anônima; precede, por exemplo, F=para usá-lo. Na verdade, é bastante rápido na entrada do 2352, levando apenas 150 milissegundos para terminar no meu computador.

ETHproductions
fonte
Eu não sei mais rápido, mas definitivamente mais curto:x=>eval("for(a=[],i=2;x>1;x%i?i++:(a.push(i),x/=i));p=[],f=(z,t=[])=>z.length?z.map((u,i)=>f([...z.slice(0,i),...z.slice(i+1)],[...t,u])):(y=t.join``)==[...y].reverse().join``&&p.push(t),f(a),p[0]||-1")
Neil
@ Neil Obrigado, isso também acontece algumas vezes mais rápido que o meu algoritmo!
ETHproductions
36 bytes? Eu acho que deve ser um recorde para mim.
Neil
0

APL (NARS), 169 caracteres, 338 bytes

∇r←F w;i;k;a;m;j
  r←⊂,w⋄→0×⍳1≥k←↑⍴w⋄a←⍳k⋄j←i←1⋄r←⍬⋄→C
A: m←i⊃w⋄→B×⍳(i≠1)∧j=m⋄r←r,m,¨∇w[a∼i]⋄j←m
B: i+←1
C: →A×⍳i≤k
∇
G←{F⍵[⍋⍵]}
f←{∨/k←{⍵≡⌽⍵}¨∊¨⍕¨¨v←Gπ⍵:↑k/v⋄¯1}

G seria a função encontrar as permutações ef é a função deste exercício; teste:

  ⎕fmt f¨11 4 39 6 1207 393 2352 
┌7───────────────────────────────────────────────────┐
│┌1──┐ ┌2───┐ ┌2────┐    ┌2─────┐    ┌7─────────────┐│
││ 11│ │ 2 2│ │ 3 13│ ¯1 │ 17 71│ ¯1 │ 2 2 7 3 7 2 2││
│└~──┘ └~───┘ └~────┘ ~~ └~─────┘ ~~ └~─────────────┘2
└∊───────────────────────────────────────────────────┘
RosLuP
fonte