दो पहले नाम

Question

एक व्यक्ति के दो पहले नाम हैं यदि उनका अंतिम नाम भी एक सामान्य पहला नाम है। आपको यह निर्धारित करने का काम सौंपा जाता है कि किसी सूची में कौन से पूर्ण नाम दो प्रथम नाम हैं।

John Smith
John Doe
Luke Ryan
Ryan Johnson
Jenna Jackson
Tom John

पहला नाम कॉलम में होने वाला कोई भी नाम संभवतः पहला नाम है। यदि प्रथम नाम कॉलम में नाम की घटनाओं की संख्या अंतिम नाम कॉलम में होने वाली घटनाओं की संख्या से अधिक है, तो यह निश्चित रूप से पहला नाम है।

उपरोक्त सूची Johnमें, पहले नामों में दो बार और अंतिम नामों में एक बार दिखाई देता है इसलिए यह निश्चित रूप से पहला नाम है। Ryanपहली बार एक बार दिखाई देता है और आखिरी में एक बार ऐसा होता है (शायद) पहला नाम।

इसलिए, Tom Johnनिश्चित रूप से दो पहले नाम हैं और Luke Ryanशायद करता है।

उपरोक्त सूची को देखते हुए, आपके कोड को निम्नलिखित का उत्पादन करना चाहिए:

Luke Ryan has two first names
Tom John definitely has two first names

---

इनपुट

जैसा कि ऊपर उल्लेख किया गया है, आपका कोड रिक्त स्थान द्वारा अलग किए गए पूर्ण नामों (मानक इनपुट से, प्रति पंक्ति) की एक सूची में ले जाएगा। नाम हाइफ़न या अक्षर लोप शामिल कर सकते हैं, लेकिन आप (एक नाम या उपनाम है कि रिक्त स्थान शामिल हैं कभी नहीं दिया जाएगा यानी कोई Liam De Rosaहै, लेकिन Liam De-Rosaया Liam De'Rosaनिष्पक्ष खेल है। दूसरे शब्दों में, नाम से मेल होगा [-'A-Za-z]+।

प्रत्येक पूर्ण नाम अद्वितीय होगा (यानी John Smithदो बार दिखाई नहीं देगा)।

उत्पादन

पूर्ण नाम (एक बार प्रति पंक्ति) नाम has two first namesया definitely has two first namesतो उसके बाद या यदि वे ऊपर दिए गए मानदंडों को पूरा करते हैं, प्रिंट करें । नाम केवल एक बार छापे जाने चाहिए।

नाम जो पहले दो नाम नहीं हैं, उन्हें मुद्रित करने की आवश्यकता नहीं है।

आपको मामले और नाम के विशेष वर्णों को संरक्षित करना होगा।

उदाहरण

इनपुट

Madison Harris
Riley Hudson
Addison Hills
Riley Phillips
Scott Hill
Levi Murphy
Hudson Wright
Nathan Baker
Harper Brooks
Chloe Morris
Aubrey Miller
Hudson Lopez
Samuel Owen
Wyatt Victoria
Brooklyn Cox
Nathan Murphy
Ryan Scott

उत्पादन

Riley Hudson definitely has two first names
Ryan Scott has two first names

इनपुट

Owen Parker
Daniel Hall
Cameron Hall
Sofia Watson
Mia Murphy
Ryan Jones
Emily Ramirez

उत्पादन

[no output]

इनपुट

Olivia Robinson
Jacob van-Dyke
Jacob Ella
Brayden De'Rosa
Levi Brook
Brook Bella
Ella Hill
Ella Anderson
Brook-Anne van-Dyke

उत्पादन

Jacob Ella definitely has two first names
Levi Brook has two first names

नोट्स और स्कोरिंग

• यह कोड गोल्फ है। सबसे कम स्कोर (बाइट्स) जीतता है।
• मानक खामियों लागू होते हैं।

सौभाग्य!

Comments

के Johnsonरूप में गिनती करता है John, या यह अलग है?

— NoOneIsHere

Johnsonसे अलग होगा John। नामों का सटीक मिलान होना चाहिए।

— मूस

हम कैसे definitely has two first namesऔर के बीच चयन करते हैं has two first names? यह हमेशा उनमें से एक हो सकता है?

— रॉड

definitelyयदि नाम पहले नाम वाले कॉलम में अंतिम नाम वाले कॉलम की तुलना में अधिक बार होता है तो ही प्रदर्शित करें। यह मामला ओवरराइड करता है, इसलिए केवल प्रदर्शन definitely has two first names। उदाहरण देखें।

— मूस

इनपुट प्रारूप कितना लचीला है? क्या यह स्ट्रिंग्स की एक सरणी हो सकती है, प्रति व्यक्ति एक? या तार का 2 डी सरणी?

— लुइस मेंडो

Answer 1

जावा (ओपनजेडके 8) , 238 222 221 220 212 बाइट्स

l->{for(String n:l){int k=0,j=0,q=0;for(String b=n.split(" ")[1];k<l.length;j+=l[k++].matches(b+" .*")?1:0)q+=l[k].endsWith(" "+b)?1:0;if(j>0)System.out.println(n+(j>q?" definitely":"")+" has two first names");}}

इसे ऑनलाइन आज़माएं!

Comments

अच्छा! आप अपनी आदतों को समाप्त कर सकते हैं k=j=q=0। इसके अलावा, यह आप किसी भी बाइट नहीं बचा होगा, लेकिन यदि आप बाद बदल सकते x+=y?1:0के साथ if(y)x++। यदि आप लंबाई को पढ़ने के बाद मुझे पसंद करते हैं, तो संभवत: यही तरीका है।

— जैकब

( Stringऔर intलूप में) डालकर आप 8 बाइट्स बचा सकते हैं :l->{for(String n:l){int k=0,j=0,q=0;for(String b=n.split(" ")[1];k<l.length;j+=l[k++].matches(b+" .*")?1:0)q+=l[k].endsWith(" "+b)?1:0;if(j>0)System.out.println(n+(j>q?" definitely":"")+" has two first names");}}

— केविन क्रूज़सेन

Answer 2

पायथन 2 , 141 137 132 130 बाइट्स

-2 बाइट्स @JonathanFrech को धन्यवाद

n=map(str.split,input())
for f,l in n:
 c=cmp(*[x.count(l)for x in zip(*n)])
 if~c:print f,l,'definitely '*c+'has two first names'

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि -c<1हो सकता है ~c, जैसा cकि कभी सकारात्मक होने के लिए प्रकट नहीं होता है।

— जोनाथन फ्रीच

Answer 3

AWK , 127 123 बाइट्स

{a[$1]++
b[L[++X]=$2]++
N[X]=$0}END{for(;++i<=X;)if(A=a[L[i]])print N[i],(b[L[i]]<A?"definitely ":"")"has two first names"}

अंतर्निहित NRमूल्य का उपयोग नहीं करके 1 बाइट की बचत ।

इसे ऑनलाइन आज़माएं!

Answer 4

पर्ल 5 , 120 118 + 2 ( -al) = 120 बाइट्स

$f{$F[0]}++;$l{$k{$_}=$F[1]}++}{map{print$_.' definitely'x($f{$t}>$l{$t})." has two first names"if$f{$t=$k{$_}}}keys%k

इसे ऑनलाइन आज़माएं!

Answer 5

रूबी , 105 129 बाइट्स

क्योंकि मैं कल्पना का हिस्सा चूक गया था

->a{a.map{|e|l=e[r=/\S+$/];i=a.count{|n|n[/\S+/]==l};e+"#{' definitely'if i>a.count{|n|n[r]==l}} has two first names"if i>0}-[p]}

इसे ऑनलाइन आज़माएं!

Answer 6

पायथन 2 , 140 127 122 131 बाइट्स

N=map(str.split,input())
F,L=zip(*N)
for f,l in N:
 if l in F:print f,l,'definitely '*(F.count(l)>L.count(l))+'has two first names'

इसे ऑनलाइन आज़माएं!

Comments

@ श्रीवत्सआर, आह, मैं गलत था। धन्यवाद :)

— TF17

Answer 7

05AB1E, 144 बाइट्स (कार्य प्रगति पर)

|vy#Dθˆн})©gF®®NèQO¯®NèQO-D®¯NèQO¯¯NèQO-D.À>0›s>0›&i0›s0›&i®Nè" "¯Nè" defínítely has two fírst names"J,ë®Nè" "¯Nè" has two fírst names"J,}ë\\}}´

Comments

नहीं, यह काम करता है, मैं सिर्फ बाइट्स की संख्या कम करने पर काम कर रहा हूं

— डेविड स्मिथ

Answer 8

05AB1E , 53 51 बाइट्स

|UXv“€°‚•€ÛŒî“D„´Î ì)yð«ìõ¸ìXð¡øεy#θQO}`.S>sèˆ}¯õK»

इसे ऑनलाइन आज़माएं!

व्याख्या

|                                                       # Take inputs as array
 UX                                                     # Store in X and push X to stack
   v                                          }         # For each name, do
    “€°‚•€ÛŒî“D                                         #   Push "has two first names" twice
               „´Î ì                                    #   Prepend "definitely " to one of those
                    )yð«ì                               #   Wrap both strings in an array and prepend (name + " ") to each
                         õ¸ì                            #   Prepend " " to array
                            Xð¡øεy#θQO}`                #   Get occurences in input first and last names
                                        .S>             #   0 for not first name, 1 for first name and 2 for definitely first name
                                           sèˆ          #   Get string at that index and push to global array
                                               ¯õK»     # Output global array, 1 string per line

या 51 I बाइट्स, मानक I / O नियम (इनपुट और आउटपुट को सरणियों के रूप में मानते हुए)

UXv“€°‚•€ÛŒî“D„´Î ì)yð«ìõ¸ìXð¡øεy#θQO}`.S>sèˆ}¯õK

इसे ऑनलाइन आज़माएं!

Answer 9

PHP, 172 बाइट्स

for(;$s=$argv[++$i];$f[$a]++,$l[$n[]=$b]++)[$a,$b]=explode(" ",$s);for(;$b=$n[+$k++];)$f[$b]<$l[$b]||print$argv[$k].($f[$b]>$l[$b]?" definetly":"")." has two first names
";

अलग कमांड लाइन तर्क के रूप में नाम लेता है।

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

Answer 10

पायथन 3, 187 बाइट्स

n={}
c=[]
while 1:
 try:a,b=input().split();n[a]=n.get(a,0)+1;n[b]=n.get(b,0)-1;c+=[[a,b]]
 except:[print(a,b,'definitely has two first names'[(n[b]>0)*11:])for a,b in c if n[b]>=0];break

Answer 11

आर , 207 बाइट्स

n=readLines("stdin")
s='definitively has two first names\n'
x=matrix(t(unlist(sapply(n,strsplit,' '))),2)
j=1
for(i in n){a=apply(x[2,j]==x,1,sum)
b=a[2]>=a[1]
if(a[1])cat(paste(i,substr(s,14*b,34)))
j=j+1}

इसे ऑनलाइन आज़माएं!

Answer 12

जावास्क्रिप्ट (ईएस 6), 149 बाइट्स

s=>s.replace(/(.*) (.*)\n/g,(_,t,u)=>g(`
${u} `)>1?t+` ${u}${v>g(` ${u}
`)?` definitely`:``} has two first names
`:``,g=u=>v=`
${s}`.split(u).length)

आई / ओ में ट्रेलिंग न्यूलाइन शामिल है। @ रॉबर्टो ग्राहम के उत्तर से काफी हद तक प्रेरित है।

Answer 13

हास्केल , 144 140 139 बाइट्स

g.map words.lines
g s=id=<<[n++' ':f++[c|c<-" definitely",t 0>t 1]++" has two first names\n"|[n,f]<-s,let t i=filter(==f)$map(!!i)s,[]<t 0]

इसे ऑनलाइन आज़माएं!

Answer 14

पॉवरशेल, 176 बाइट्स

$n=$args
$s=" has two first names"
$f=$n|%{$_.Split()[0]}
$l=$n|%{$_.Split()[1]}
$i=0
$l|%{switch(($f-match$_).count){{$_-eq1}{$n[$i]+$s}{$_-gt1}{$n[$i]+" definitely"+$s}}$i++}