Dado um número inteiro positivo como entrada, determine se é um número magnânimo.

Um número magnânimo é um número tal que qualquer inserção de um +sinal entre dois dígitos na base 10 resulta na expressão de um número inteiro primo.

Por exemplo, 40427 é magnânimo porque

4+0427  = 431  is prime
40+427  = 467  is prime
404+27  = 431  is prime
4042+7  = 4049 is prime

Saída

Você deve gerar dois valores distintos, um quando a entrada for magnânima e outro quando a entrada não for.

Pontuação

O objetivo deste concurso será tornar o tamanho do código fonte escrito para resolver esta tarefa, fornecida em bytes, o menor possível.

Casos de teste

1       -> True
2       -> True
4       -> True
10      -> False
98      -> True
101     -> True
109     -> False
819     -> False
4063    -> True
40427   -> True
2000221 -> True

OEIS 253996

05AB1E , 10 bytes

Código

η¨¹.s¨R+pP

Usa a codificação 05AB1E . Experimente online! ou Verifique todos os casos de teste!

Explicação

η¨             # Take the prefixes of the input and remove the last element
  ¹.s¨         # Take the suffixes of the input and remove the last element
      R        # Reverse the array of suffixes
       +       # Vectorized addition
        p      # Check if each element is prime
         P     # Product of the array

C (gcc) , 8384 85 83 84 86 75 111 bytes

Todas as otimizações foram desativadas e somente no GCC de 32 bits.

-1 byte graças a @ceilingcat

+ alguns bytes para 1maiúsculas e minúsculas.

+ alguns bytes para funções reutilizáveis.

i,j,r,s;f(a){for(i=10,r=1;a/i;i*=10)for(s=a%i+a/i,r*=s-1,j=2;j<s;)r*=s%j++>0;a=!r;}

Recebe a entrada como um número inteiro. Retorne 1 para casos falsos, 0 para casos verdadeiros.

Experimente online!

Veja minha outra resposta para o código do Mathematica (55 bytes).

Retina , 38 bytes

\B
$`$*_$'$*_
S`\d
G`^_$|^(__+)\1+$
^$

Experimente online!

Imprime 1para números magnânimos e 0outros.

Explicação

\B
$`$*_$'$*_

Começamos combinando cada posição entre dois dígitos (posições que não são limites de palavras) e inserindo o prefixo e o sufixo dessa correspondência em unário, usando _como dígito unário. Então, em vez de inserir +s, inserimos diretamente o resultado unário da soma.

S`\d

Agora dividimos a string em torno de dígitos, para que cada soma entre em sua própria linha e nos livramos desses dígitos (haverá uma linha à esquerda e à esquerda também, mas isso não é importante).

G`^_$|^(__+)\1+$

Este é o regex padrão para corresponder a números não primos em unário. Usar um Gestágio de repetição aqui significa que simplesmente mantemos todas as linhas que contêm não-primos positivos (descartando as linhas vazias).

^$

Finalmente, verificamos se a string está vazia. Se a entrada foi magnânima, o estágio anterior descartará todas as linhas (porque eram todas primas), e isso nos dá 1. Caso contrário, se alguma linha não for primordial, ela permanecerá na sequência e o regex falhará, dando 0.

Python 2 , 82 79 78 bytes

f=lambda n,d=10:n<d or d/n<all((n/d+n%d)%k*f(n,10*d)for k in range(2,n/d+n%d))

Isso é lento e só pode lidar com os casos de teste com memorização.

Experimente online!

Versão alternativa, 79 bytes

f=lambda n,d=10:n<d or f(n,10*d)>d/n<all((n/d+n%d)%k for k in range(2,n/d+n%d))

Acelerou ao custo de um byte.

Experimente online!

Gelatina , 12 bytes

DJ⁵*⁸dṖS€ÆPẠ

Experimente online!

Verifique todos os casos de teste.

Java 8, 175 171 94 88 bytes

n->{long d=10,r=0,i,t;for(;d<=n;d*=10,r|=t-i)for(t=n/d+n%d,i=1;t%++i%t>0;);return r==0;}

-77 graças a @PeterTaylor usando uma aritmética (em vez de String com .substring) e se livrando do método separado para verificar se o número inteiro é primo.
-6 bytes usando o método de verificação primária do @SaraJ , portanto, faça um voto positivo !

Experimente aqui.

Explicação:

n->{                  // Method with long as both parameter and return-type
  long d=10,r=0,i,t;  //  Some temp longs
  for(;d<=n           //  Loop as long as `d` is below or equal to input `n`
                      //  (inclusive instead of exclusive due to special case 10)
      ;               //    After every iteration:
       d*=10,         //     Multiple `d` by 10
       r|=t-i)        //     and Bitwise-OR `r` with `t-i`
    for(t=n/d+n%d,    //   Set `t` to `n` integer-divided by `d` plus `n` modulo-`d`
        i=1;          //   Set `i` to 1
        t%++i%t>0;);  //   Inner oop as long as `t` modulo `i+1` modulo `t` is not 0 yet
                      //   (after we've first increased `i` by 1 with `++i`)
                      //   (if `t` equals `i` afterwards, it means `t` is a prime)
  return r==0;}       //  Return if `r` is still 0

Pitão , 14 bytes

.AmP_ssMcQ]dtU

Experimente online! Será exibido Truese o número for magnânimo, Falsecaso contrário. Pega o número como uma sequência.

Explicações

.AmP_ssMcQ]dtU

              Q    # Implicit input Q
            tU     # Generate the range [1, 2, ..., len(Q)-1]
  m                # For each index d in the above range...
        cQ]d       # Split Q at index d
      sM           # Convert the two parts to integers
     s             # Sum
   P_              # Check it is a prime
.A                 # ...end for. Check all elements are True

Python 2 , 104 102 98 96 103 bytes

• Graças ao @Wheat Wizard por 2 bytes: tornado icompletamente anônimo, pois é chamado apenas uma vez.
• Graças ao @ Hyperperutrutrino por 4 bytes: maneira mais inteligente de obter os números do número principal em vez de cortar
• @Hyperneutrino salvou outros 2 bytes: x-1apenas xpara o rarnge de verificação principal.
• Corrigida falha no caso x=10, adicionando 7 bytes, graças ao @Dennis e ao @Wheat Wizard por detectá-lo: minha versão anterior estava considerando 1 como primo

lambda x:all((lambda x:x>1and all(x%j for j in range(2,x)))(x/10**j+x%10**j)for j in range(1,len(`x`)))

Experimente online!

Japonês , 24 16 bytes

Foi uma colaboração entre @Shaggy, @ETHproduction e eu.

¬£[YîU UtY]xÃÅej

Experimente online!

Recebe a entrada como uma sequência.

Pip , 25 24 bytes

$&0N_%,_=1M$+(a^@_)M1,#a

Experimente online!

Explicação

aé o primeiro argumento da linha de comandos. 1,#agera um intervalo contendo números 1até len(a)-1. Para isso, mapeamos uma função lambda:

$+(a^@_)
   a^@_   Split a at this index
$+(    )  Fold the resulting 2-element list on +

A seguir, mapeamos outra função lambda 0N_%,_=1, que testa primalidade. Eu peguei desta resposta ; você pode ler a explicação lá. Finalmente, dobramos a lista em AND lógico ( $&). O resultado é 1se todas as somas eram primárias, 0se nenhuma delas não era.

Exemplo, com entrada de 4063:

                    1,#a   [1; 2; 3]
           $+(a^@_)M       [67; 103; 409]
  0N_%,_=1M                [1; 1; 1]
$&                         1

CJam , 22 bytes

r:L,({)_L<i\L>i+mp!},!

Experimente online!

Imprime inteiro positivo para verdade, zero para falsidade.

-1 graças a um truque inteligente de Peter Taylor .
-3 graças a outra dica de Peter Taylor.

Japonês , 23 bytes

Recebe a entrada como uma sequência.

Dang it; derrotado no soco em uma alternativa muito mais curta na qual eu estava trabalhando.

£i+Ýe@OxXr"%+0+"'+)j

Teste-o

Mathematica, 75 bytes

And@@Table[PrimeQ@ToExpression@StringInsert[#,"+",n],{n,2,StringLength@#}]&

Functionque espera a String. PrimeQ@ToExpression@StringInsert[#,"+",n]retorna se a inserção de um +após o ndígito th fornece um número primo. Table[...,{n,2,StringLength@#}]fornece a lista desses valores como nintervalos do 2comprimento da sequência. Em seguida, extraímos Andcada um dos elementos dessa lista. Convenientemente, se StringLength@#<2, então Table[...]é a lista vazia, para a qualAnd@@{}==True

Mathematica, 55 50. 45 49. 50. 54 62 bytes

Parece que devo publicá-lo separadamente.

+6 bytes para o tamanho do código medido novamente.

+5 bytes graças a ngenisis.

And@@(qPrimeQ[#~Mod~q+⌊#/q⌋])@Rest@PowerRange@#&

Pega a entrada como um número inteiro e retorna regular Truee False. O meio é o unicode 0xF4A1, abreviação de Function[,]. O tamanho do código é medido no tamanho do arquivo (UTF-8 sem BOM), comente se não estiver correto.

PowerRange[x]retorna 1, 10, 100 ... não é maior que x, que é introduzido no Mathematica 10.

Inglês simples 4.204 341 315 251 241 240 bytes

(Re) incorporou o teste de primalidade à biblioteca da Plain English, movendo 3.863 bytes para a biblioteca da Plain English. Excluídos 26 bytes de espaço em branco. Economizou 64 bytes abreviando variáveis ​​locais. Economizou 10 bytes abreviando a interface. Por sugestão do RosLuP , economize 1 byte alterando como m é inicializado e incrementado.

To decide if a n number is g:
Put 1 in a m number.
Loop.
Multiply the m by 10.
If the m is greater than the n, say yes.
Divide the n by the m giving a q quotient and a r remainder.
Add the q to the r.
If the r is not prime, say no.
Repeat.

Versão não destruída do código final:

To decide if a number is magnanimous:
  Put 1 in another number.
  Loop.
    Multiply the other number by 10.
    If the other number is greater than the number, say yes.
    Divide the number by the other number giving a quotient and a remainder.
    Add the quotient to the remainder.
    If the remainder is not prime, say no.
  Repeat.

Notas: O IDE do inglês simples está disponível em github.com/Folds/english . O IDE é executado no Windows. Ele é compilado no código x86 de 32 bits.

O fork dinâmico do inglês simples da Ordem Osmosian já tinha testes de primalidade na versão 4700, mas usava um algoritmo muito ineficiente (de janeiro a junho de 2017). As versões 4001-4011 do fork dinâmico do site GitHub omitiram o teste de primalidade. A versão 4013 do fork dinâmico do site GitHub inclui teste de primalidade. O código para executar o teste de primalidade foi desenvolvido como parte de revisões anteriores desta resposta.

Perl 6 , 58 bytes

{?(10,10* *...^*>$_).map({$_ div$^a+$_%$^a}).all.is-prime}

Experimente online!

10, 10 * * ...^ * > $_é a sequência geométrica de múltiplos de dez, tirada até uma antes do elemento que excede o parâmetro de entrada $_. Depois, verificamos que, para cada potência de dez, a soma do parâmetro de entrada obtido div e mod é a potência principal.

Haskell, 114 110 bytes

p x=[x]==[i|i<-[2..x],x`mod`i<1]
i!x|i<1=0<1|0<1=p(uncurry(+)$divMod x$10^i)&&(i-1)!x
f x=(length(show x)-1)!x

Ungolfed com explicação:

-- Check if x is a prime number
p x = [x] == [i | i<-[2..x], x`mod`i < 1]
-- Checks all pairs of numbers a '+' can be put in between
i ! x | i<1 = 0<1                                -- Single-digit numbers are always truthy
      | 0<1 = p (uncurry (+) $ divMod x $ 10^i)  -- Does x split at i digits from right sum up to a prime?
           && (i-1) ! x                          -- If so, check next pair
-- Start (!) with the number of digits in x minus one
f x = (length (show x)-1) ! x

Axioma, 88 bytes

f(n:PI):Boolean==(i:=10;repeat(q:=n quo i;q=0 or ~prime?(q+n rem i)=>break;i:=i*10);q=0)

teste e resultados

(10) -> [[i,f(i)]  for i in [1,2,4,10,98,101,109,819,4063,40427,2000221,999999999999999999999999999999999999999999999]]
   (10)
   [[1,true], [2,true], [4,true], [10,false], [98,true], [101,true],
    [109,false], [819,false], [4063,true], [40427,true], [2000221,true],
    [999999999999999999999999999999999999999999999 ,false]]

Braquilog , 11 bytes

{~cĊℕᵐ+}ᶠṗᵐ

Experimente online!

{      }ᶠ      Find every
      +        sum of
   Ċ           two
    ℕᵐ         whole numbers
 ~c            which concatenate to the input,
          ᵐ    and assert that all of them
         ṗ     are prime.

Perl 6 , 35 bytes

{m:ex/^(.+)(.+)$/.all.sum.is-prime}

Experimente online!

Explicação:

{                                 }     # Anonymous code block that
 m:ex/^        $/                         # Match all
       (.+)(.+)                           # Splits of the input number
                 .all                     # Are all of them
                     .sum                   # When summed
                         .is-prime          # Prime?

Empilhados , 51 bytes

[tostr:#'1-~>splitat tr['+',' '#`#~prime]map 1,all]

Experimente online!

Esta é uma função. Ele funciona convertendo seu argumento em uma string ( tostr), duplicando-o e obtendo seu comprimento ( :#'), subtraindo 1 ( 1-), variando de 1 a esse número ( ~>). A pilha se parece com isso, para entrada 40427:

('40427' (1 2 3 4))

Executamos vetorizados splitat, resultando na seguinte matriz para estar no topo da pilha:

(('4' '40' '404' '4042') ('0427' '427' '27' '7'))

Transpondo isso tr, obtemos:

(('4' '0427') ('40' '427') ('404' '27') ('4042' '7'))

Em seguida, mapeamos a função ['+',' '## ~ prime] (withmap`). Esta função faz:

['+',' '#`#~prime]
 '+',                concatenate a plus sign (string)    `('4' '0427' '+')
     ' '#`           join by spaces                      `'4 0427 +'`
          #~         evaluate                            `431`
            prime    check primality                     `1`

Depois, depois do mapa, concatenamos 1. Isso ocorre desde que allretorna undefpara uma lista vazia.

JavaScript (ES6), 70 bytes

P=(n,x=2)=>n%x?P(n,x+1):n==x
f=(n,i=10)=>i>n||P((n/i|0)+n%i)&f(n,i*10)

Falha no último caso no meu navegador devido a um erro "muita recursão" durante o cálculo P(200023). Espero que isso não o invalide.

QBIC , 38 bytes

_L;|[a-1|q=q*µ!_sA,b|!+!_sA,b+1,a|!}?q

Explicação

_L |     Create a variable a and set it to the length of
  ;      the input string (A$)
[a-1|    FOR b = 1 to a-1
q=q*     multiply q by
 µ       -1 if prime, 0 if not, of
  !        a cast of 
   _s       a substring of
     A,       A$
     b        from index 1 to index b (only one index is given, so that is assumed to be the req. length from 1)
      |!   to number
 +         plus
 !         a cast of
  _s         a substring of
    A,         A$
    b+1        from index b+1
    ,a         for the length of a (does not error if it exceeds the end of the string)
      |!   to number
 }       NEXT 
 ?q      PRINT q, which is eitrher -1 or 1 for all-prime sums, or 0 otherwise

CJam (21 bytes)

r:R,({RiA@)#md+mp!},!

Demonstração online , conjunto de testes on-line

Dissecação

r:R       e# Take a token of input and assign it to R
,(        e# Take the length of R minus one
{         e# Filter i = 0 to (length of R minus two)
  Ri      e#   Push R as an integer value
  A@)#    e#   Push 10 to the power of (i + 1)
  md      e#   divmod
  +mp!    e#   Add, primality test, negate result
},        e# The result of the filter is a list of splits which give a non-prime
!         e# Negate result, giving 0 for false and 1 for true

Pitão, 15 14 bytes

.AmP_svcz]dtUz

Suíte de teste

Salvou um byte usando a mais nova alteração de Pyth.

APL (NARS), caracteres 35, bytes 70

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}

teste:

  f←{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
  f¨1 2 4 10 98 101 109 819 4063 40427 2000221
1 1 1 0 1 1 0 0 1 1 1 

Esta seria a tradução em APL do Axiom post algo aqui ...

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
 0≥k←¯1+≢⍕⍵:1⋄  assign to k the length as array of argument return 1 if that is <=0
 ∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k
              m←10*⍳k  m is the array pow(10,1..k)
           ⌊⍵÷m       the array of quotient of argumet with m
          +           sum 
     (m∣⍵)            with array of remander
   0π                 build the binary array of "are prime each"
 ∧/                   and that array

PHP, 100 bytes

for(;++$k<strlen($a=$argn);$x+=$i==1)for($i=$n=substr($a,$k)+$b.=$a[$k-1];--$i&&$n%$i;);echo$x+2>$k;

imprime 1se a entrada for magnânima, se não houver saída vazia. Execute como pipe -nRou experimente online .

Perl 5 -p , 42 bytes

$\=1;s//map$\&&=($`+$')%$_,2..$`+$'-1/ge}{

Experimente online!