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
1
com um sinal de adição inserido entre dois caracteres (sem inserção), isso pode resultar apenas1
, o que por si só não é primo.1
e2
sem dois dígitos, o conjunto de expressões está vazio. Todos os membros do conjunto vazio são primos. Além disso, nenhum deles é, mas isso é além do ponto. É um pouco confuso, vou lhe dar isso, mas acho que faz mais sentido do que as alternativas.Respostas:
05AB1E , 10 bytes
Código
Usa a codificação 05AB1E . Experimente online! ou Verifique todos os casos de teste!
Explicação
fonte
1 - 9
? O produto de um conjunto vazio é 1? Por quê?1
e multiplicando-o por cada item do conjunto, então ...sum
on[]
é equivalente0
, o uso da propriedade induction ao implementar foi bastante inteligente.C (gcc) , 83
848583848675111bytesTodas as otimizações foram desativadas e somente no GCC de 32 bits.
-1 byte graças a @ceilingcat
+ alguns bytes para
1
maiúsculas e minúsculas.+ alguns bytes para funções reutilizáveis.
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).
fonte
1
,98
, e4063
.Retina , 38 bytes
Experimente online!
Imprime
1
para números magnânimos e0
outros.Explicação
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.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).
Este é o regex padrão para corresponder a números não primos em unário. Usar um
G
está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á, dando0
.fonte
Python 2 ,
827978 bytesIsso é lento e só pode lidar com os casos de teste com memorização.
Experimente online!
Versão alternativa, 79 bytes
Acelerou ao custo de um byte.
Experimente online!
fonte
Gelatina , 12 bytes
Experimente online!
Verifique todos os casos de teste.
fonte
d
!Java 8,
1751719488 bytes-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:
fonte
p
por recursão; em segundo lugar, acumule os resultados de modo que a função principal exija apenas umareturn
instrução, criando o valor sentinela dep
be-1
e usando&
para verificar se todos os valores retornados são-1
.n->{for(long d=10,m=1;d<n;d*=10)m|=p(n/d+n%d,2)-2;return m>0;}long p(long n,int i){return i<n?p(n%i<1?1:n,i+1):n;}
d<=n
para lidar10
. O estouro de pilha não é um problema (a especificação não fornece um intervalo de entrada que deve ser tratado), mas pode ser corrigido e mais economias são obtidas ao se reverter para um loop e inlining .Pitão , 14 bytes
Experimente online! Será exibido
True
se o número for magnânimo,False
caso contrário. Pega o número como uma sequência.Explicações
fonte
Python 2 ,
104 102 98 96103 bytesi
completamente anônimo, pois é chamado apenas uma vez.x-1
apenasx
para o rarnge de verificação principal.x=10
, adicionando 7 bytes, graças ao @Dennis e ao @Wheat Wizard por detectá-lo: minha versão anterior estava considerando 1 como primoExperimente online!
fonte
x-1
no final do intervalo; a gama é exclusiva à direita.Japonês ,
2416 bytesFoi uma colaboração entre @Shaggy, @ETHproduction e eu.
Experimente online!
Recebe a entrada como uma sequência.
fonte
x
converte automaticamente os itens na matriz de números ;-)XîU
é genial. Eu acho queU¯X
funciona para o mesmo comprimento, mas aindaPip ,
2524 bytesExperimente online!
Explicação
a
é o primeiro argumento da linha de comandos.1,#a
gera um intervalo contendo números1
atélen(a)-1
. Para isso, mapeamos uma função lambda: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 é1
se todas as somas eram primárias,0
se nenhuma delas não era.Exemplo, com entrada de
4063
:fonte
CJam , 22 bytes
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.
fonte
0&!
é mais curto que1+:*
!
retorna um conjunto-intersecção boolean e usados com o valor Falsas0
de modo que você pode fazer0&!
no 3 em vez de1&!!
...,
operador de filtro em vez def
.!
ao converter para um booleano: isso era padrão no GolfScript e padrão no CJam. E1&!!
seria incorreto:0&!
é o teste óbvio porque o requisito é todo, não existe.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.
Teste-o
fonte
¬£i+YÄÃe@OxX j
4063
(deve ser verdadeiro, é falso). O truque aqui é que JS acha que um líder0
significa que você quer octal ...40043
, por exemplo) Basta adicionar um+
após o0
para corrigir isso.Mathematica, 75 bytes
Function
que espera aString
.PrimeQ@ToExpression@StringInsert[#,"+",n]
retorna se a inserção de um+
após on
dígito th fornece um número primo.Table[...,{n,2,StringLength@#}]
fornece a lista desses valores comon
intervalos do2
comprimento da sequência. Em seguida, extraímosAnd
cada um dos elementos dessa lista. Convenientemente, seStringLength@#<2
, entãoTable[...]
é a lista vazia, para a qualAnd@@{}==True
fonte
Mathematica, 55
50.4549.50.5462bytesParece que devo publicá-lo separadamente.
+6 bytes para o tamanho do código medido novamente.
+5 bytes graças a ngenisis.
Pega a entrada como um número inteiro e retorna regular
True
eFalse
. O
meio é o unicode 0xF4A1, abreviação deFunction[,]
. 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 quex
, que é introduzido no Mathematica 10.fonte
Inglês simples
4.204341315251241240 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.
Versão não destruída do código final:
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.
fonte
Perl 6 , 58 bytes
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.fonte
Haskell,
114110 bytesUngolfed com explicação:
fonte
p x=[x]==[i|i<-[2..x],x`mod`i<1]
como cheque principal, poderá salvar 2 bytes.divMod x$10^i
vez dex`divMod`(10^i)
Axioma, 88 bytes
teste e resultados
fonte
Braquilog , 11 bytes
Experimente online!
fonte
Perl 6 , 35 bytes
Experimente online!
Explicação:
fonte
Empilhados , 51 bytes
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 entrada40427
:Executamos vetorizados
splitat
, resultando na seguinte matriz para estar no topo da pilha:Transpondo isso
tr
, obtemos:Em seguida, mapeamos a função
['+',' '#
# ~ prime](with
map`). Esta função faz:Depois, depois do mapa, concatenamos
1
. Isso ocorre desde queall
retornaundef
para uma lista vazia.fonte
JavaScript (ES6), 70 bytes
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.fonte
QBIC , 38 bytes
Explicação
fonte
CJam (21 bytes)
Demonstração online , conjunto de testes on-line
Dissecação
fonte
Pitão,
1514 bytesSuíte de teste
Salvou um byte usando a mais nova alteração de Pyth.
fonte
APL (NARS), caracteres 35, bytes 70
teste:
Esta seria a tradução em APL do Axiom post algo aqui ...
fonte
PHP, 100 bytes
imprime
1
se a entrada for magnânima, se não houver saída vazia. Execute como pipe-nR
ou experimente online .fonte
Perl 5
-p
, 42 bytesExperimente online!
fonte