Palavras Duplas Primeiras
Considere uma palavra / string de comprimento \$n\$, incluindo apenas as letras AZ, az. Uma palavra / string é uma palavra dupla primo se e somente se n for primo e a soma das letras, s, também for primo, usando sua posição numérica no alfabeto ( a=1, B=2, c=3, etc.).
A entrada pode ser qualquer combinação de caracteres alfabéticos maiúsculos ou minúsculos, pois não há diferença numérica entre aou A.
A saída é qualquer formato lógico apropriado relacionado ao seu idioma. isto é, verdadeiro ou falso, T ou F, 1 ou 0, etc. Especificar em qual formato sua saída aparecerá é muito apreciado, mas não obrigatório. (A saída não precisa incluir n, s, mas incluo-os abaixo como demonstração e exemplo)
A condição de vitória é o código mais curto em bytes capaz de detectar se uma string é um primo duplo, ajustando ambas as condições para n e s serem primos. (Agora incluí casos de todas as 4 situações possíveis de n, s.)
Exemplos
Input -> Output (n, s)
Prime -> True (5, 61)
han -> True (3, 23)
ASK -> True (3, 31)
pOpCoRn -> True (7, 97)
DiningTable -> True (11, 97)
METER -> True (5, 61)
Hello -> False (5, 52)
SMILE -> False (5, 58)
frown -> False (5, 76)
HelpMe -> False (6, 59)
John -> False (4, 47)
TwEnTy -> False (6, 107)
HelloWorld -> False (10, 124)
Donald -> False (6, 50)
telePHONES -> False (10, 119)
A -> False (1, 1)
C -> False (1, 3) {1 is not prime}
d -> False (1, 4)
Respostas
Jelly , 12 bytes
ŒuO_64µL,SẒP
Como funciona
ŒuO_64µL,SẒP - Main link, takes string s as argument e.g. s = "Prime"
Œu - Convert to upper case "PRIME"
O - Convert to ordinals [80, 82, 73, 77, 69]
_64 - Subtract 65 (call this L) [16, 18, 9, 13, 5]
µ - Start a new link with L as the left argument
L - Take the length 5
S - Take the sum 61
, - Pair the two values [5, 61]
Ẓ - Take primality of each [1, 1]
P - Take product 1
R , 68 71 bytes
+3 bytes para corrigir um bug apontado por Dominic van Essen
`?`=sum;s=?b<-utf8ToInt(scan(,""))%%32;l=?b^0;l-1&5>?c(!s%%1:s,!l%%1:l)
Observe que, para converter letras maiúsculas e minúsculas em inteiros 1 ... 26, podemos sum(!x%%1:x)usar o ponto de código ASCII módulo 32. é uma maneira prática de contar o número de divisores de x, que será igual a 2 sse xé primo.
Ungolfed:
`?` = sum # shorthand for sum
b = utf8ToInt(scan(, "")) %% 32 # take input and convert to ASCII, then take mod 32
s = sum(b)
l = sum(b^0) # l = length(b)
5 > sum(c(!s%%1:s,!l%%1:l)) # sum the number of divisors of s and l, and check whether you get <5.
& l!=1 # and that l is not 1
Ruby , 27 59 bytes
->a{[a.size,a.upcase.bytes.map{|i|i-64}.sum].all? &:prime?}
+33 bytes após corrigir a solução, graças a DrQuarius.
perl -Mfeature = diga -MList :: Util = sum -pl, 95 bytes
s/[^a-z]//gi;$m=sum map-64+ord,split//,uc;$_=(1 x y===c)!~/^(11+)\1+$|^1$/&&(1x$m)!~/^(11+)\1$/
Como funciona?
s/[^a-z]//gi; # Clean the input, remove anything which isn't an ASCII letter.
uc; # Upper case the string
split//, # Split it into individual characters
-64+ord # Calculate its value:
# subtract 64 from its ASCII value
map # Do this for each character, return a list
$m=sum # Sum the values, and store it in $m
y===c # Returns the length of the input string
(1 x y===c) # Length of the input string in unary
/^(11+)\1+$|^1$/ # Match a string consisting of a composite
# number of 1's, or a single 1
!~ # Negates the match, so
(1 x y===c)1~/^(11+)\1+$|^1$/ # this is true of the input string (after
# cleaning) has prime length
(1x$m)!~/^(11+)\1+$/ # Similar for the sum of the values --
# note that the value is at least 2, so
# no check for 1.
Combinando isso, o programa imprimirá 1 nas linhas que correspondem às condições e uma linha em branco nas linhas que não correspondem.
05AB1E , 10 bytes
gAIlk>O‚pP
Insira como uma lista de personagens.
Experimente online ou verifique todos os casos de teste .
Explicação:
g # Get the length of the (implicit) input-list
A # Push the lowercase alphabet
I # Push the input-list of characters
l # Convert the input to lowercase
k # Get the (0-based) index of each character in the alphabet-string
> # Increase each by 1 to make them 1-based indices
O # Take the sum of that
‚ # Pair the length together with this sum
p # Check for both whether they're a prime (1 if it's a prime; 0 if not)
P # And check if both are truthy by taking the product of the pair
# (after which the result is output implicitly)
R , 70 bytes
function(s,S=sum,t=S(utf8ToInt(s)%%32))S(!nchar(s)%%1:t)^S(!t%%1:t)==4
Obriguei-me a não dar uma olhada na resposta de Robin Ryder antes de tentar , e (com satisfação) descobrimos que usamos alguns truques de golfe bem diferentes.
té o total de todos os índices de letras. É certo que é maior ou igual a nchar(s)(só é igual se a string sfor "A" ou "a"). Portanto, podemos usar o módulo 1:tpara testar a primalidade do comprimento da string em vez do módulo 1:nchar(s), e não há necessidade de desperdiçar caracteres em uma declaração de variável para armazenar nchar(s).
Ambos os testes de primalidade sum(!t%%1:t)e sum(!nchar(s)%%1:t)devem ser iguais a 2 se os índices da soma das letras e o comprimento da string forem primos.
Poderíamos verificar se ambos são 2, mas isso requer ==2duas vezes (mais um &ou equivalente), o que parece um desperdício. Posso verificar se o total é 4? O caso extremo com o qual precisamos nos preocupar é se um deles é igual a 1 e o outro 3: isso acontece para a string "D" (comprimento = 1 e índice de caractere = 4 com divisores 1,2 e 4). Portanto, não está tudo bem. Podemos multiplicá-los? Também não, porque 1 e 4 darão novamente 4 (pense na string "F").
Mas - já que sabemos que o comprimento da string deve ser menor ou igual à soma dos índices de caracteres, podemos usar a exponenciação: a única maneira de obter 4 é 4 ^ 1 ou 2 ^ 2, e desde os índices de soma de caracteres não podem ser 1 se o comprimento da string for 4, 2 ^ 2 é a única possibilidade.
Portanto, a verificação final combinada para primalidade dupla é sum(!nchar(s)%%1:t)^sum(!t%%1:t)==4salvar 3 personagens em comparação com testá-los separadamente.
Rockstar , 327 321 319 bytes
Não integrado para testes primos!
Sem conversão de caixa!
Não há como obter o ponto de código de um personagem!
Por que eu faço essas coisas comigo mesmo ?! Gastei tanto tempo apenas para fazer a maldita coisa funcionar, tenho certeza de que está longe de ser um jogo de golfe ideal, mas servirá por enquanto.
F takes N
let D be N
let P be N aint 1
while P and D-2
let D be-1
let M be N/D
turn up M
let P be N/D aint M
return P
G takes I
Y's0
N's27
while N
cast N+I into C
if C is S at X
return N
let N be-1
return G taking 64
listen to S
X's0
T's0
while S at X
let T be+G taking 96
let X be+1
say F taking T and F taking X
Experimente aqui (o código terá de ser colado)
Retina 0.8.2 , 77 bytes
\W|\d|_
$
¶$`
\G.
1
T`L`l
[t-z]
55$&
[j-z]
55$&
T`_l`ddd
.
$*
A`^(..+)\1+$
¶
Experimente online! O link inclui casos de teste. Explicação:
\W|\d|_
Exclua tudo o que não seja uma letra.
$
¶$`
Duplique as letras.
\G.
1
Substitua as letras da primeira linha por 1s, tomando o comprimento em unário.
T`L`l
Converta as letras restantes em minúsculas.
[t-z]
55$&
[j-z]
55$&
T`_l`ddd
Converta-os em dígitos que somarão suas posições numéricas.
.
$*
Converta os dígitos em unários, calculando a soma deles.
A`^(..+)\1+$
Exclua quaisquer valores compostos.
¶
Verifique se os dois valores ainda estão presentes.
Python 3 , 86 78 87 bytes
Economizei 8 bytes graças ao ovs !!!
Adicionados 9 bytes para corrigir um bug gentilmente apontado por Robin Ryder .
lambda s:~-len(s)*all(n%i for n in(len(s),sum(ord(c)&31for c in s))for i in range(2,n))
Retorna um valor verdadeiro ou falso.
Brachylog , 11 bytes
ḷạ-₉₆ᵐ+ṗ&lṗ
Como funciona
ḷạ-₉₆ᵐ+ṗ&lṗ (is the implicit input)
ḷ to lowercase
ạ to list of char codes
-₉₆ᵐ minus 96 (so 'a' -> 1)
+ summed
ṗ prime?
&l and is the input's length
ṗ prime?
J , 27 22 18 bytes
1*/@p:#,1#.32|3&u:
-5 bytes graças ao xash
-4 bytes graças a Dominic van Essen
32|3&u:Transforme cada letra em seu índice, primeiro convertendo para seu número ascii, o modding por 32.1#.Soma.#,Prefixe o comprimento da lista.1...p:Cada um desses dois números são primos?*/@Multiplique-os juntos - são todos primos?
C - 119 108 99 98 bytes (gcc)
@ceilingcat salvou outro byte!
b,t,e;p(c){for(;--e&&c%e;);c=e==1;}a(char*a){t=0;for(e=b=strlen(a);b;)t+=a[--b]%32;t=p(e)*p(e=t);}
anteriormente
Muito obrigado a @DominicvanEssen e @ceilingcat por economizar 20 bytes! - e particularmente para Dominic por corrigir o erro em n = 1 (não primo)
b,t,e;p(c){for(b=c;--b&&c%b;);c=b==1;}a(char*a){t=0;for(e=b=strlen(a);b;)t+=a[--b]%32;t=p(e)*p(t);}
primeira tentativa abaixo de 119 bytes
a(char*a){int t=0,d=strlen(a),e=d;while(d)t+=a[--d]%32;return p(e)*p(t);}
p(int c){int b=c;while(--b&&c%b);return b<2;}
Na verdade, pode economizar 3 bytes usando while(c%--b)na segunda rotina, mas isso falha para o caso de p (1), por exemplo, 'a'. ou outros caracteres únicos.
Scala , 75 74 69 bytes
| =>p(|size)&p(|map(_&95-64)sum)
def p(n:Int)=(2 to n/2)forall(n%_>0)
Fator , 78 bytes
: d ( s -- ? ) dup [ length ] dip >lower [ 96 - ] map sum [ prime? ] bi@ and ;
JavaScript (Node.js) , 88 bytes
Retorna 0 ou 1 .
s=>(g=k=>n%--k?g(k):k==1)(Buffer(s).map(c=>x+=n<(n+=c>64&(c&=31)<27&&c),x=n=0)|n)&g(n=x)
Comentou
Função auxiliar
g = k => // g is a helper function testing if n is prime
n % --k ? // decrement k; if it does not divide n:
g(k) // do recursive calls until it does
: // else:
k == 1 // test whether k = 1
Função principal
s => // s = input string
g( // test if the 'sum of the letters' is prime
Buffer(s).map(c => // for each ASCII code c in s:
x += // increment x if ...
n < ( // ... n is less than ...
n += // ... the new value of n:
c > 64 & // if c is greater than 64
(c &= 31) < 27 // and c mod 32 is less than 27:
&& c // add c mod 32 to n
), //
x = n = 0 // start with x = n = 0
) | n // end of map(); yield n
) // end of the first call to g
& g(n = x) // 2nd call to g with the 'length' x
Perl 5 -pl , 52 bytes
Usa o regex de identificação principal da resposta de @Abigail
$_.=$".1x s/./1x(31&ord$&)/ge;$_=!/\b((11+)\2+|1)\b/
Ruby , 50 55 50 bytes
->s{[s.size,s.upcase.sum-64*s.size].all? &:prime?}
+5 bytes devido a um mal-entendido sobre se os arrays podem ser considerados verdadeiros.
-5 bytes graças a Razetime, usando o belo truque de colocar o "&: prime?" no final ao invés de fazer um ".map (&: prime?)" antes de ".all?".
Postado separadamente porque a solução de Razetime, na verdade, não soma o índice alfabético, mas simplesmente os ordinais ascii. Ele falha para as palavras principais duplas "DiningTable" e "METER" .
Husk , 12 bytes
&ṗL¹ṗṁȯ-64ca
Experimente online! Produz um número verdadeiro se a palavra for uma palavra dupla primo e 0 caso contrário.