Parole doppie prime
Considera una parola / stringa di lunghezza \$n\$, includendo solo le lettere AZ, az. Una parola / stringa è una doppia parola prima se e solo se n è primo e anche la somma delle lettere, s, è primo, utilizzando la loro posizione numerica nell'alfabeto ( a=1, B=2, c=3, ecc.).
L'input può essere qualsiasi combinazione di caratteri alfabetici maiuscoli o minuscoli, poiché non vi è alcuna differenza numerica tra ao A.
L'output è un formato logico appropriato correlato alla tua lingua. cioè Vero o Falso, T o F, 1 o 0, ecc. Specificare il formato in cui apparirà l'output è molto apprezzato, ma non obbligatorio. (L'output non deve includere n, s, ma li includo di seguito come dimostrazione ed esempio)
La condizione vincente è il codice più breve in byte in grado di rilevare se una stringa è un doppio primo, adattando entrambe le condizioni affinché n e s siano primi. (Ora ho incluso casi da tutte e 4 le possibili situazioni di n, s.)
Esempi
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)
Risposte
Gelatina , 12 byte
ŒuO_64µL,SẒP
Come funziona
Œ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 byte
+3 byte per correggere un bug segnalato da Dominic van Essen
`?`=sum;s=?b<-utf8ToInt(scan(,""))%%32;l=?b^0;l-1&5>?c(!s%%1:s,!l%%1:l)
Si noti che per convertire sia le lettere maiuscole che quelle minuscole negli interi 1 ... 26, possiamo prendere il codepoint ASCII modulo 32. sum(!x%%1:x)è un modo golfistico di contare il numero di divisori di x, che sarà uguale a 2 se xe solo 1 .
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 byte
->a{[a.size,a.upcase.bytes.map{|i|i-64}.sum].all? &:prime?}
+33 byte dopo aver corretto la soluzione, grazie a DrQuarius.
perl -Mfeature = say -MList :: Util = sum -pl, 95 byte
s/[^a-z]//gi;$m=sum map-64+ord,split//,uc;$_=(1 x y===c)!~/^(11+)\1+$|^1$/&&(1x$m)!~/^(11+)\1$/
Come funziona?
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 questo, il programma stamperà 1 sulle righe che corrispondono alle condizioni e una riga vuota per le righe che non corrispondono.
05AB1E , 10 byte
gAIlk>O‚pP
Inserimento come elenco di caratteri.
Provalo online o verifica tutti i casi di test .
Spiegazione:
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 byte
function(s,S=sum,t=S(utf8ToInt(s)%%32))S(!nchar(s)%%1:t)^S(!t%%1:t)==4
Mi sono sforzato di non sbirciare la risposta di Robin Ryder prima di provare a farlo, e (in modo soddisfacente) si scopre che abbiamo usato alcuni trucchi da golf piuttosto diversi.
tè il totale di tutti gli indici di lettere. Questo è sicuramente maggiore di o uguale a nchar(s)(è uguale solo se la stringa sè "A" o "a"). Quindi possiamo usare modulo 1:tper testare la primalità della lunghezza della stringa invece di modulo 1:nchar(s), e non è necessario sprecare caratteri in una dichiarazione di variabile da memorizzare nchar(s).
Entrambe le verifiche di primalità sum(!t%%1:t)e sum(!nchar(s)%%1:t)devono essere uguali a 2 se entrambi gli indici della somma delle lettere e la lunghezza della stringa sono primi.
Potremmo controllare se sono entrambi 2, ma questo richiede ==2due volte (più uno &o equivalente), il che sembra uno spreco. Va bene controllare che il totale sia 4? Il caso limite di cui dobbiamo preoccuparci è se uno dei due è uguale a 1 e l'altro a 3: questo accade per la stringa "D" (lunghezza = 1 e carattere-indice = 4 con divisori 1,2 e 4). Quindi non va bene. Possiamo moltiplicarli? Inoltre no, perché 1 e 4 daranno di nuovo 4 (pensa alla stringa "F").
Ma, poiché sappiamo che la lunghezza della stringa deve essere minore o uguale agli indici della somma dei caratteri, possiamo usare l'elevamento a potenza: l'unico modo per ottenere 4 è 4 ^ 1 o 2 ^ 2, e poiché la somma degli indici dei caratteri non può essere 1 se la lunghezza della stringa è 4, 2 ^ 2 è l'unica possibilità.
Quindi il controllo finale combinato per la doppia primalità è sum(!nchar(s)%%1:t)^sum(!t%%1:t)==4salvare 3 caratteri rispetto a testarli separatamente.
Rockstar , 327 321 319 byte
Nessun built-in per testare i numeri primi!
Nessuna conversione del caso!
Nessun modo per ottenere il codice di un personaggio!
Perché faccio queste cose a me stesso ?! Ho passato così tanto tempo solo a far funzionare quella dannata cosa, sono sicuro che è tutt'altro che ottimamente giocato a golf, ma per ora andrà bene.
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
Provalo qui (il codice dovrà essere incollato)
Retina 0.8.2 , 77 byte
\W|\d|_
$
¶$`
\G.
1
T`L`l
[t-z]
55$&
[j-z]
55$&
T`_l`ddd
.
$*
A`^(..+)\1+$
¶
Provalo online! Il collegamento include casi di test. Spiegazione:
\W|\d|_
Elimina tutto ciò che non è una lettera.
$
¶$`
Duplica le lettere.
\G.
1
Sostituisci le lettere sulla prima riga con 1s, prendendo così la lunghezza in unario.
T`L`l
Converti le lettere rimanenti in minuscolo.
[t-z]
55$&
[j-z]
55$&
T`_l`ddd
Convertirli in cifre che si sommeranno alla loro posizione numerica.
.
$*
Converti le cifre in unarie, ottenendo così la loro somma.
A`^(..+)\1+$
Elimina tutti i valori composti.
¶
Verificare che entrambi i valori siano ancora presenti.
Python 3 , 86 78 87 byte
8 byte salvati grazie a ovs !!!
Aggiunti 9 byte per correggere un bug gentilmente segnalato da 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))
Restituisce un valore vero o falso.
Brachylog , 11 byte
ḷạ-₉₆ᵐ+ṗ&lṗ
Come funziona
ḷạ-₉₆ᵐ+ṗ&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 byte
1*/@p:#,1#.32|3&u:
-5 byte grazie a xash
-4 byte grazie a Dominic van Essen
32|3&u:Trasforma ogni lettera nel suo indice convertendola prima nel suo numero ASCII, il modding di 32.1#.Somma.#,Anteponi la lunghezza dell'elenco.1...p:Ciascuno di questi due numeri è primo?*/@Moltiplicali insieme: sono tutti primi?
C - 119108 99 98 byte (gcc)
@ceilingcat ha salvato un altro 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);}
in precedenza
Mille grazie a @DominicvanEssen e @ceilingcat per aver salvato 20 byte! - e in particolare a Dominic per aver corretto l'errore su n = 1 (non 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);}
primo tentativo inferiore a 119 byte
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;}
In effetti può salvare 3 byte utilizzando while(c%--b)nella seconda routine, ma questo fallisce nel caso di p (1) ad esempio 'a'. o altri singoli caratteri.
Scala , 75 74 69 byte
| =>p(|size)&p(|map(_&95-64)sum)
def p(n:Int)=(2 to n/2)forall(n%_>0)
Fattore , 78 byte
: d ( s -- ? ) dup [ length ] dip >lower [ 96 - ] map sum [ prime? ] bi@ and ;
JavaScript (Node.js) , 88 byte
Restituisce 0 o 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)
Commentato
Funzione di aiuto
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
Funzione principale
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 byte
Utilizza la regex di identificazione principale dalla risposta di @ Abigail
$_.=$".1x s/./1x(31&ord$&)/ge;$_=!/\b((11+)\2+|1)\b/
Ruby , 50 55 50 byte
->s{[s.size,s.upcase.sum-64*s.size].all? &:prime?}
+5 byte a causa di un malinteso sul fatto che gli array possano essere considerati veritieri.
-5 byte grazie a Razetime, usando il simpatico trucco di mettere "&: prime?" alla fine invece di fare un ".map (&: prime?)" prima di ".all?".
Postato separatamente perché la soluzione di Razetime in realtà non sommava l'indice alfabetico ma semplicemente gli ordinali ascii. Non riesce per le doppie parole prime "DiningTable" e "METER" .
Husk , 12 byte
&ṗL¹ṗṁȯ-64ca
Provalo online! Restituisce un numero vero se la parola è una parola doppia prima e 0 in caso contrario.