दोहरा प्रधान शब्द
लंबाई का एक शब्द / स्ट्रिंग पर विचार करें \$n\$केवल अक्षर AZ, az सहित। एक शब्द / स्ट्रिंग एक डबल प्राइम शब्द है अगर और केवल अगर n अभाज्य है और वर्णों का योग भी है, तो, वर्णमाला ( a=1, B=2, c=3, आदि) में उनकी संख्यात्मक स्थिति का उपयोग करते हुए ।
इनपुट ऊपरी या निचले मामले के अक्षर वर्णनों का कोई भी संयोजन हो सकता है, क्योंकि aया के बीच कोई संख्यात्मक अंतर नहीं है A।
आउटपुट आपकी भाषा से संबंधित कोई उपयुक्त तार्किक प्रारूप है। सही या गलत, टी या एफ, 1 या 0, आदि। निर्दिष्ट करें कि आपका आउटपुट किस प्रारूप में दिखाई देगा, इसकी बहुत सराहना की जाती है, लेकिन इसकी आवश्यकता नहीं है। (आउटपुट में n, s शामिल नहीं है, लेकिन मैं उन्हें प्रदर्शन और उदाहरण के रूप में नीचे शामिल करता हूं)
जीतने की स्थिति बाइट्स में सबसे छोटा कोड है जो यह पता लगाने में सक्षम है कि क्या एक स्ट्रिंग डबल प्राइम है, एन और एस के लिए दोनों शर्तों को प्रधान करने के लिए फिटिंग। (मैंने अब n, s की सभी 4 संभावित स्थितियों से मामलों को शामिल किया है।)
उदाहरण
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)
जवाब
जेली , 12 बाइट्स
ŒuO_64µL,SẒP
इसे ऑनलाइन आज़माएं!
यह काम किस प्रकार करता है
Œ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
आर , 68 71 बाइट्स
डोमिनिक वैन एसेन द्वारा इंगित बग को ठीक करने के लिए +3 बाइट्स
`?`=sum;s=?b<-utf8ToInt(scan(,""))%%32;l=?b^0;l-1&5>?c(!s%%1:s,!l%%1:l)
इसे ऑनलाइन आज़माएं!
ध्यान दें कि ऊपरी और निचले दोनों प्रकार के अक्षरों को पूर्णांक 1 ... 26 में बदलने के लिए, हम ASCII sum(!x%%1:x)कोडपॉइंट मॉडुलो 32 ले सकते हैं। के विभक्तों की संख्या की गणना का एक गोल्फ़ तरीका है x, जो 2 iff के बराबर होगा x।
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
रूबी , 27 59 बाइट्स
->a{[a.size,a.upcase.bytes.map{|i|i-64}.sum].all? &:prime?}
+33 बाइट्स समाधान को सही करने के बाद, DrQuarius को धन्यवाद।
इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें
perl -Mfeature = say -MList :: Util = sum -pl, 95 बाइट्स
s/[^a-z]//gi;$m=sum map-64+ord,split//,uc;$_=(1 x y===c)!~/^(11+)\1+$|^1$/&&(1x$m)!~/^(11+)\1$/
इसे ऑनलाइन आज़माएं!
यह कैसे काम करता है?
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.
इसे मिलाकर, और प्रोग्राम उन लाइनों पर 1 प्रिंट करेगा जो शर्तों से मेल खाते हैं, और लाइनों के लिए एक खाली लाइन जो मेल नहीं खाते हैं।
05AB1E , 10 बाइट्स
gAIlk>O‚pP
वर्णों की सूची के रूप में इनपुट।
इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।
स्पष्टीकरण:
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)
आर , 70 बाइट्स
function(s,S=sum,t=S(utf8ToInt(s)%%32))S(!nchar(s)%%1:t)^S(!t%%1:t)==4
इसे ऑनलाइन आज़माएं!
मैंने अपने आप को इस पर शॉट लगाने से पहले रॉबिन राइडर के जवाब को देखने के लिए मजबूर नहीं किया , और (संतोष से) यह पता चला कि हमने कुछ अलग गोल्फिंग ट्रिक्स का इस्तेमाल किया है।
tसभी पत्र सूचकांकों का कुल योग है। यह अधिक से अधिक-या-बराबर-होना निश्चित है nchar(s)(यह केवल समान है यदि स्ट्रिंग s"ए" या "ए" है)। इसलिए हम modulo 1:tके बजाय स्ट्रिंग की लंबाई की शुद्धता के लिए परीक्षण करने के लिए modulo का उपयोग कर सकते हैं 1:nchar(s), और स्टोर करने के लिए एक चर घोषणा पर अपशिष्ट पात्रों की कोई आवश्यकता नहीं है nchar(s)।
दोनों समरूपता परीक्षण sum(!t%%1:t)और sum(!nchar(s)%%1:t)2 के बराबर होना चाहिए, यदि राशि-पत्र-सूचक और स्ट्रिंग लंबाई दोनों प्रमुख हैं।
हम जांच कर सकते हैं कि क्या वे दोनों 2 हैं, लेकिन इसके लिए ==2दो बार (साथ &या एक बराबर) की आवश्यकता होती है , जो बेकार लगता है। क्या यह जांचना ठीक है कि कुल 4 है? जिस एज-केस के बारे में हमें चिंता करने की ज़रूरत है, अगर उनमें से एक 1 और दूसरे 3 के बराबर है: यह स्ट्रिंग "डी" (लंबाई = 1 और चरित्र-सूचकांक = 4 के साथ भाजक 1,2 और 4) के लिए होता है। तो यह ठीक नहीं है। क्या हम उन्हें गुणा कर सकते हैं? इसके अलावा नहीं, क्योंकि 1 और 4 फिर से 4 देंगे (स्ट्रिंग "एफ" के बारे में सोचें)।
लेकिन - जब से हम जानते हैं कि स्ट्रिंग की लंबाई योग-वर्ण-सूचकांकों के बराबर या उससे कम होनी चाहिए, हम घातांक का उपयोग कर सकते हैं: 4 पाने का एकमात्र तरीका 4 ^ 1 या 2 ^ 2 है, और चूंकि यदि स्ट्रिंग की लंबाई 4, 2 ^ 2 है तो एकमात्र संभावना चरित्र-सूचकांकों की संख्या 1 नहीं हो सकती है।
तो डबल-प्राइमलिटी के लिए अंतिम, संयुक्त जांच है sum(!nchar(s)%%1:t)^sum(!t%%1:t)==4, 3 पात्रों को अलग से परीक्षण करने की तुलना में बचत करना।
रॉकस्टार , 327 321 319 बाइट्स
कोई अंतर्निहित अंतर्निहित परीक्षण अपराधों के लिए!
कोई मामला रूपांतरण नहीं!
किसी चरित्र का कोडपाइंट पाने का कोई तरीका नहीं!
मैं ये बातें खुद से क्यों करूँ? काम करने के लिए सिर्फ इतना ही समय मिल रहा है, मुझे यकीन है कि यह अभी तक गोल्फ से दूर है, लेकिन यह अभी के लिए करूँगा।
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
इसे यहां आज़माएं (कोड को पेस्ट करना होगा)
रेटिना 0.8.2 , 77 बाइट्स
\W|\d|_
$ ¶$`
\G.
1
T`L`l
[t-z]
55$& [j-z] 55$&
T`_l`ddd
.
$* A`^(..+)\1+$
¶
इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:
\W|\d|_
एक पत्र नहीं है कि कुछ भी हटा दें।
$ ¶$`
अक्षरों को डुप्लिकेट करें।
\G.
1
पहली पंक्ति में अक्षरों को 1एस के साथ बदलें , इस प्रकार लंबाई को एकात्मक रूप में लें।
T`L`l
शेष पत्रों को निचले मामले में परिवर्तित करें।
[t-z]
55$& [j-z] 55$&
T`_l`ddd
उन्हें उन अंकों में परिवर्तित करें जो उनकी संख्यात्मक स्थिति के लिए योग करेंगे।
.
$*
अंकों को एकात्मक में परिवर्तित करें, इस प्रकार उनका योग ले।
A`^(..+)\1+$
किसी भी समग्र मान को हटाएँ।
¶
जांचें कि दोनों मान अभी भी मौजूद हैं।
पायथन 3 , 86 78 87 बाइट्स
सहेजा गया 8 बाइट्स ओव्स के लिए धन्यवाद !!! रॉबिन राइडर
द्वारा इंगित एक बग को ठीक करने के लिए 9 बाइट्स जोड़े गए ।
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))
इसे ऑनलाइन आज़माएं!
एक सत्य या गलत मूल्य देता है।
ब्रेकीलॉग , 11 बाइट्स
ḷạ-₉₆ᵐ+ṗ&lṗ
इसे ऑनलाइन आज़माएं!
यह काम किस प्रकार करता है
ḷạ-₉₆ᵐ+ṗ&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?
वोल्फ्राम भाषा (गणितज्ञ) , 34 बाइट्स
PrimeQ@*Tr/@(LetterNumber@#&&1^#)&
इसे ऑनलाइन आज़माएं!
@ बट्ट से -22 बाइट्स
जाप , 16 बाइट्स
Êj ©Uu ¬mc xaI j
कोशिश करो
जम्मू , 27 22 18 बाइट्स
1*/@p:#,1#.32|3&u:
इसे ऑनलाइन आज़माएं!
-5 बाइट्स एक्सश के लिए धन्यवाद
डोमिनिक वैन एसेन को -4 बाइट्स धन्यवाद
32|3&u:प्रत्येक अक्षर को उसके ascii नंबर में परिवर्तित करके, उसके अक्षर को 32 से मोड़कर, उसके सूचकांक में बदल दें।1#.योग।#,सूची की लंबाई बढ़ाएँ।1...p:क्या उन दो संख्याओं में से प्रत्येक प्रमुख हैं?*/@उन्हें एक साथ गुणा करें - क्या वे सभी प्रमुख हैं?
सी - 119 108 99 98 बाइट्स (जीसीसी)
@ceilingcat ने बचाई एक और बाइट!
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);}
इसे ऑनलाइन आज़माएं
पहले से
20 बाइट्स बचाने के लिए @DominicvanEssen और @ceilingcat को बहुत धन्यवाद! - और विशेष रूप से n = 1 पर त्रुटि को ठीक करने के लिए डोमिनिक (गैर-प्राइम)
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);}
119 बाइट्स के नीचे पहला प्रयास
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;}
वास्तव while(c%--b)में दूसरी दिनचर्या में उपयोग करके 3 बाइट्स बचा सकते हैं , लेकिन यह p (1) उदा 'a' के मामले में विफल रहता है। या अन्य एकल वर्ण।
इसे ऑनलाइन आज़माएं
स्काला , 75 74 69 बाइट्स
| =>p(|size)&p(|map(_&95-64)sum)
def p(n:Int)=(2 to n/2)forall(n%_>0)
इसे ऑनलाइन आज़माएं!
फैक्टर , 78 बाइट्स
: d ( s -- ? ) dup [ length ] dip >lower [ 96 - ] map sum [ prime? ] bi@ and ;
इसे ऑनलाइन आज़माएं!
05AB1E , 11 बाइट्स
uÇ64-Op¹gp&
इसे ऑनलाइन आज़माएं!
इनपुट प्रतिबंधों की कमी के कारण बाइट्स हटा दिए गए
जावास्क्रिप्ट (Node.js) , 88 बाइट्स
रिटर्न 0 या 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)
इसे ऑनलाइन आज़माएं!
टिप्पणी की गई
हेल्पर फ़ंक्शन
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
मुख्य कार्य
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
पर्ल 5 -pl , 52 बाइट्स
@ अबीगैल के उत्तर से प्रमुख पहचान regex का उपयोग करता है
$_.=$".1x s/./1x(31&ord$&)/ge;$_=!/\b((11+)\2+|1)\b/
इसे ऑनलाइन आज़माएं!
रूबी , 50 55 50 बाइट्स
->s{[s.size,s.upcase.sum-64*s.size].all? &:prime?}
इसे ऑनलाइन आज़माएं!
+5 बाइट्स की गलतफहमी के कारण कि क्या सरणियों को सत्य माना जा सकता है।
-5 बाइट्स रेज़ाइम के लिए धन्यवाद, "&: प्राइम?" ".all?" से पहले ".map (&: Prime?)" करने के बजाय अंत में।
अलग से पोस्ट किया गया क्योंकि रेज़ाइम का समाधान वास्तव में वर्णमाला सूचकांक नहीं था, लेकिन बस एससीआई अध्यादेश। यह दोहरे प्रमुख शब्दों "डाइनिंगटेबल" और "METER" के लिए विफल हो जाता है ।
भूसी , 12 बाइट्स
&ṗL¹ṗṁȯ-64ca
इसे ऑनलाइन आज़माएं! यदि शब्द दोहरा प्रधान शब्द है, और 0 अन्यथा, तो एक सत्य संख्या को आउटपुट करता है।