सबसे लगातार शब्द क्या है?


26

सबसे लगातार शब्द क्या है?

एक वाक्य को देखते हुए, आपके कार्यक्रम को इसके माध्यम से अपना रास्ता बनाना चाहिए, प्रत्येक शब्द की आवृत्तियों की गणना करना, फिर सबसे अधिक उपयोग किए जाने वाले शब्द का उत्पादन करना। क्योंकि एक वाक्य की कोई निश्चित लंबाई नहीं है, और इसलिए बहुत लंबा हो सकता है, आपका कोड यथासंभव छोटा होना चाहिए।

नियमों / आवश्यकताओं

  • प्रत्येक सबमिशन या तो एक पूर्ण कार्यक्रम या फ़ंक्शन होना चाहिए। यदि यह एक फ़ंक्शन है, तो प्रोग्राम के निचले भाग में फ़ंक्शन कॉल को जोड़ने की आवश्यकता के द्वारा इसे चलाने योग्य होना चाहिए। कुछ भी (जैसे सी में हेडर) शामिल किया जाना चाहिए।
  • आपकी भाषा के लिए एक नि: शुल्क दुभाषिया / संकलक उपलब्ध होना चाहिए।
  • यदि यह संभव है, तो उस साइट का लिंक प्रदान करें जहां आपके कार्यक्रम का परीक्षण किया जा सकता है।
  • आपके प्रोग्राम को कुछ भी नहीं लिखना चाहिए STDERR
  • आपके कार्यक्रम को STDIN(या आपकी भाषा में निकटतम विकल्प) से इनपुट लेना चाहिए ।
  • मानक खामियों को मना किया जाता है।
  • आपका कार्यक्रम केस-संवेदी होना चाहिए ( tHe, Theऔर theसभी की गिनती करने के लिए योगदान the)।
  • यदि कोई सबसे लगातार शब्द नहीं है (परीक्षण केस # 3 देखें), तो आपके प्रोग्राम को कुछ भी आउटपुट नहीं करना चाहिए।

'शब्द' की परिभाषा:

आप रिक्त स्थान पर इनपुट पाठ को विभाजित करके शब्दों की सूची प्राप्त करते हैं। इनपुट में प्लेन स्पेस की तुलना में किसी भी अन्य प्रकार का व्हाट्सएप कभी भी नहीं होगा (विशेष रूप से कोई न्यूलाइन्स नहीं)। हालाँकि, अंतिम शब्दों में केवल अल्फ़ान्यूमेरिक्स (az, AZ, 0-9), हाइफ़न (-) और apostrophes (') शामिल होना चाहिए। आप अन्य सभी वर्णों को हटाकर या शब्द विभाजन करने से पहले उन्हें अंतरिक्ष द्वारा प्रतिस्थापित करके ऐसा कर सकते हैं। नियमों के पिछले संस्करणों के साथ संगत रहने के लिए, एपोस्ट्रोफ को शामिल करने की आवश्यकता नहीं है।

परीक्षण के मामलों

The man walked down the road.
==> the

-----

Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.
==> he

-----

This sentence has no most frequent word.
==> 

-----

"That's... that's... that is just terrible!" he said.
==> that's / thats

-----

The old-fashioned man ate an old-fashioned cake.
==> old-fashioned

-----

IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.
==> IPv6

-----

This sentence with words has at most two equal most frequent words.
==>

नोट: तीसरे और सातवें परीक्षण के मामलों में कोई आउटपुट नहीं है, आप चौथे पर भी चुन सकते हैं।

स्कोरिंग

कार्यक्रम बाइट्स के अनुसार बनाए जाते हैं। सामान्य वर्ण सेट UTF-8 है, यदि आप एक और कृपया निर्दिष्ट का उपयोग कर रहे हैं।

जब चुनौती पूरी हो जाती है, तो कम से कम बाइट्स (इसे कहा जाता है ) वाला कार्यक्रम जीत जाएगा।

प्रस्तुतियाँ

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।


2
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
दरवाज़े

1
तो 'शब्द' की अपनी नई परिभाषा देते हुए, यहां सबसे सामान्य शब्द कौन सा है don't d'ont dont a a? यह होगा dont?
DJMcMayhem

@DrGreenEggsand HamDDJ यदि आपके पास एक सबमिशन है जो एपोस्ट्रोफिस को दूर करता है dont,। हैं, तो नहीं a। लेकिन अधिकांश प्रस्तुतियाँ करते हैं, और इसलिए dontएक सही उत्तर है।
जॉर्ज गिब्सन

1
आउटपुट केस-संवेदी है? तो ipv6पिछले परीक्षण मामले के लिए वैध उत्पादन है?
kirbyfan64sos

1
एक अतिरिक्त परीक्षण मामला उपयोग का हो सकता है: "शब्दों के साथ इस वाक्य में दो सबसे बराबर सबसे अधिक बार होने वाले शब्द हैं।" -> <कुछ नहीं>
फिलॉब्बरोन

जवाबों:


6

पाइके, 26 25 बाइट्स

l1dcD}jm/D3Sei/1qIi@j@
(;

यहाँ कोशिश करो!

या 23 22 बाइट्स (नॉनकंपेटिंग, नोड जोड़ें जहां स्टैक को मारता है यदि गलत है)

l1cD}jm/D3Sei/1q.Ii@j@

यहाँ कोशिश करो!

या विराम चिह्न के साथ, 23 बाइट्स (मुझे लगता है कि यह प्रतिस्पर्धा है; प्रतिबद्धता संपादित करने से पहले थी)

l1.cD}jm/D3Sei/1q.Ii@j@

यहाँ कोशिश करो!

या 12 बाइट्स (निश्चित रूप से नॉनकमेटिंग)

l1.cj.#jR/)e

यहाँ कोशिश करो!

l1           -     input.lower()
  .c         -    punc_split(^)
    j        -   j = ^
     .#   )  -  sort(V(i) for i in ^)
       jR/   -   j.count(i)
           e - ^[-1]

यदि आपका एकमात्र विराम चिह्न संरक्षित था -और '(हाइफ़न और एपोस्ट्रोफ़) तो आपका 23 बाइट उत्तर प्रतिस्पर्धा करेगा ।
जॉर्ज गिब्सन

यह केवल विराम चिह्न को सुरक्षित रखता है जो एक शब्द के अंत में नहीं है
ब्लू

ओह, ठीक है (मुझे पेक समझ में नहीं आता)। मुझे लगता है कि यह तब प्रतिस्पर्धा करता है ...
जॉर्ज गिब्सन

1
@GeorgeGibson मुझे पूरा यकीन है कि 23 बाइट संस्करण प्रतिस्पर्धा नहीं करेंगे - यह मानक खामियों के तहत आ सकता है। इसके अलावा, मैं पेक को समझने के लिए किसी भी लोग (एम) की उम्मीद नहीं करता, मैं इसे अपनी भाषा के रूप में बना रहा हूं
ब्लू

तो ठीक है। मुझे लगता है कि आप अभी भी वैसे भी जीतते हैं, इसलिए यह वास्तव में मायने नहीं रखता।
जॉर्ज गिब्सन


11

पायथ - 23 30 बाइट्स

अंकों और हाइफ़न को शामिल करने का एक बेहतर तरीका होना चाहिए, लेकिन मैं अभी इसे ठीक करना चाहता हूं।

Kc@s+++GUTd\-rzZ)I!tJ.M/KZ{KhJ

टेस्ट सूट


1
संशोधित नियमों के लिए अंकों और हाइफ़न को संरक्षित करने की आवश्यकता होती है।
डेनिस

@GeorgeGibson तय।
माल्टसेन

6

ऑक्टेव, 115 94 बाइट्स

[a,b,c]=unique(regexp(lower(input('')),'[A-z]*','match'));[~,~,d]=mode(c); try disp(a{d{:}})

मामले का उपयोग न करके सबसे लगातार शब्द के साथ try। इस मामले में यह कुछ भी नहीं करता है, और जब तक आप अपवाद को नहीं पकड़ लेते हैं, तब तक "ब्रेक लेता है"।

लुइस मेंडो के सुझाव ( modeसबसे आम शब्द प्राप्त करने के लिए तीसरे आउटपुट का उपयोग करके) के लिए धन्यवाद, बचे हुए 21 (!) बचे ।


जब से मैंने अपना मूल उत्तर पोस्ट किया है, नियम काफी बदल गए हैं। मैं बाद में regex में देखूंगा।


1
तुम मुझे इसके लिए हराओ, अब कुछ और सोचने के लिए।
अब्रीराम

शायद modeपर लागू करें c? इसका तीसरा आउटपुट सभी बंधे हुए मूल्य देता है, अगर मुझे सही ढंग से याद है
लुइस मेंडू

मैं 115 बाइट्स गिनता हूं।
कॉनर ओ'ब्रायन

मेरा मानना ​​है कि आपका रेगेक्स होना चाहिए ['\w\d]क्योंकि आपको एपोस्ट्रोफिस और अंकों को संरक्षित करना होगा । जब तक वे ASCII में ऊपरी और निचले मामले के बीच नहीं होते हैं, उस स्थिति में मुझे अनदेखा करें क्योंकि मेरे पास टेबल काम नहीं है।
निधि मोनिका का मुकदमा

1
@StewieGriffin [~, ~, out] = mode([1 1 2 2 1 2 3 4 5 5])देता हैout = {1 2}
लुइस

5

पर्ल 6, 80 बाइट्स

{$_>1&&.[0].value==.[1].value??""!!.[0].key given .lc.words.Bag.sort:{-.value}}

चलिए जवाब को दो भागों में विभाजित करते हैं ...

given .lc.words.Bag.sort:{-.value}

givenएक नियंत्रण कथन (जैसे ifया for) है। पर्ल 6 में, उन्हें पोस्टफिक्स के रूप में अनुमति दी गई है। ( a if 1, या यहाँ की तरह foo given 3)। givenइसके विषय (दाएं हाथ की ओर) को $_इसके बाएं हाथ के लिए विशेष चर में रखता है।

"विषय" खुद को नीचा दिखाता है ( lc), शब्द से विभाजित होता है ( words), मानों को एक थैले में रखता है (घटनाओं की संख्या के साथ सेट), फिर मूल्य (DESC) के आधार पर छाँटें। के बाद से sortही जानता है सूचियों पर संचालित करने के लिए कैसे, Bagएक में तब्दील हो जाता Listका Pairरों यहाँ।

$_>1&&.[0].value==.[1].value??""!!.[0].key

एक साधारण सशर्त ( ?? !!बजाय पर्ल 6 में उपयोग किया जाता है ? :)।

$_ > 1

बस जाँचता है कि सूची में एक से अधिक तत्व हैं।

.[0].value==.[1].value

एक्सेस को $_छोटा किया जा सकता है ... चर को निर्दिष्ट नहीं करके। .aवास्तव में की तरह है $_.a। तो यह प्रभावी रूप से "क्या दोनों शीर्ष तत्वों में समान संख्याएँ होती हैं" - यदि ऐसा है, तो हम '' (खाली स्ट्रिंग) प्रिंट करते हैं।

अन्यथा, हम शीर्ष तत्व की कुंजी (गिनती) प्रिंट करते हैं .[0].key:।


7
यह आधी अंग्रेजी, आधी लाइन-शोर की तरह है। गजब का।
बिल्ली

1
यह अजीब है कि यह ओओ-शैली की विशेषताएं कैसे हैं जो अंग्रेजी-वाई दिखती हैं: पी
वें

2
पर्ल 5 से अधिक अंग्रेजी होते हुए भी पर्ल 5 से कम पठनीय होने का प्रबंधन करता है :
बिल्ली

1
@ इसे तय किया - अब पूरी तरह से अपठनीय होना चाहिए
वेन

5
value??!!(मुझे पता है कि यह एक टर्नरी ऑपरेटर है, यह सिर्फ मनोरंजक है)
बिल्ली

4

05AB1E , 30 बाइट्स

कोड:

lžj¨„ -«Ãð¡©Ùv®yQOˆ}®¯MQÏDg1Q×

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!



3
@TessellatingHeckler यह केवल इनपुट की एक पंक्ति लेता है। जब तक आप बार-बार Iकमांड का उपयोग नहीं करते हैं , तब तक 05AB1E केवल उतना ही लेगा, जितनी उसे जरूरत है।
जॉर्ज गिब्सन

4

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

s=>(m=new Map,s.toLowerCase().replace(/[^- 0-9A-Z]/gi,'').split(/\ +/).map(w=>m.set(w,-~m.get(w))),[[a,b],[c,d]]=[...m].sort(([a,b],[c,d])=>d-b),b==d?'':a)

@ ब्लू के पायथन उत्तर के आधार पर।


आपका रेगेक्स रिप्लेस दिखता है जैसे यह संख्याओं को गिराता है, और आईपीवी 6 परीक्षण मामले को तोड़ देगा, क्या यह सही है?
TessellatingHeckler

@TessellatingHeckler जब से मैंने मूल रूप से प्रश्न पढ़ा है, तब से शब्द की परिभाषा बदल गई है, लेकिन मैंने अपना उत्तर अब अपडेट कर दिया है।
नील

4

पायथन 3.5, 142 137 134 112 117 110 110 बाइट्स:

( +17 बाइट्स, क्योंकि स्पष्ट रूप से भले ही बाकी की तुलना में अधिक बार शब्द हों, लेकिन उनकी आवृत्ति समान है, फिर भी कुछ भी वापस नहीं आना चाहिए। )

def g(u):import re;q=re.findall(r"\b['\-\w]+\b",u.lower());Q=q.count;D=[*map(Q,{*q})];return['',max(q,key=Q)][1in map(D.count,D)]

अब सभी शर्तों को पूरा करना चाहिए। यह सबमिशन मानता है कि कम से कम 1 शब्द इनपुट है।

यह ऑनलाइन की कोशिश करो! (Ideone)

इसके अलावा, यदि आप एक चाहते हैं, तो यहां लगभग 43 बाइट्स की कीमत पर किसी भी नियमित अभिव्यक्ति से रहित मेरे फ़ंक्शन का एक और संस्करण है, हालांकि यह एक गैर-प्रतिस्पर्धी वैसे भी है, इसलिए यह वास्तव में कोई फर्क नहीं पड़ता। मैंने इसे यहाँ इसके लिए रखा है:

def g(u):import re;q=''.join([i for i in u.lower()if i in[*map(chr,range(97,123)),*"'- "]]).split();Q=q.count;D=[*map(Q,{*q})];return['',max(q,key=Q)][1in map(D.count,D)]

इस नए संस्करण को ऑनलाइन आज़माएं! (Ideone)


चुनौती की टिप्पणियों से "यदि दो शब्द हैं जो बाकी की तुलना में अधिक हैं, लेकिन एक ही आवृत्ति के साथ", आउटपुट 'कुछ भी नहीं' है।
रूटट्वो

@RootTwo फिक्स्ड! :)
आर। काप

@TessellatingHeckler हालांकि वे अलग-अलग शब्द हैं। जबकि वास्तव में एक शब्द नहीं है के That'sलिए एक संकुचन है। that isthats
आर। कप

@TessellatingHeckler क्या आप मुझे इस टिप्पणी का कुछ प्रमाण दे सकते हैं? क्योंकि मैं पोस्ट पर सभी टिप्पणियों से गुजर रहा हूं और ऐसी कोई टिप्पणी नहीं देख रहा हूं।
आर। कप

4

रूबी, 94 92 102 बाइट्स

जल्दी जाना (FGITW जवाब)। शब्द को सभी अपरकेस में लौटाता है, या nilयदि कोई सबसे लगातार शब्द नहीं है।

अब मैं नए चश्मे के लिए अद्यतन, मुझे लगता है। हालाँकि, मैंने थोड़ा नीचे गोल्फ का प्रबंधन किया इसलिए बाइट की गिनती समान है!

->s{w=s.upcase.tr("_'",'').scan /[-\w]+/;q=->x{w.count x};(w-[d=w.max_by(&q)]).all?{|e|q[e]<q[d]}?d:p}

5
Gotta go fast?
बिल्ली

@cat हाँ, 'cuz I इस बार FGITW था
वैल्यू इंक



3

Sqlserver 2008, 250 बाइट्स

DECLARE @ varchar(max) = 'That''s... that''s... that is just terrible!" he said.';

WITH c as(SELECT
@ p,@ x
UNION ALL
SELECT LEFT(x,k-1),STUFF(x,1,k,'')FROM
c CROSS APPLY(SELECT patindex('%[^a-z''-]%',x+'!')k)k
WHERE''<x)SELECT max(p)FROM(SELECT top 1with ties p
FROM c WHERE p>''GROUP BY p
ORDER BY count(*)DESC
)j HAVING count(*)=1

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

Sqlserver 2016, 174 बाइट्स

इस उदाहरण की तरह डेटा को संभालने में असमर्थ (3 शब्दों के बराबर की गिनती):

DECLARE @ varchar(max) = 'That''s... that''s... that is just terrible!" he said. = = ='

SELECT max(v)FROM(SELECT TOP 1WITH TIES value v
FROM STRING_SPLIT(REPLACE(REPLACE(REPLACE(@,'"',''),',',''),'.',''),' ')GROUP
BY value ORDER BY count(*)DESC)x HAVING count(*)=1

मुझे चर दृष्टिकोण पसंद नहीं है क्योंकि यह धोखा देने का एक प्रकार है :) एक इनपुट -> कुछ भी या कुछ भी नहीं, सेट-आधारित दृष्टिकोण के साथ इसे लंबा होना है, क्योंकि आपको अतिरिक्त जोड़ने की आवश्यकता है GROUP BY, LEFT JOIN, or PARTITION BYSQL सर्वर SPLIT फ़ंक्शन में बनाया गया है। Ungolfed डेमो इसे यथासंभव छोटा बनाने के लिए स्वतंत्र महसूस करता है।
लाड 2025

@ lad2025 बहुत बहुत धन्यवाद, 2016 से कोई भी सुविधाओं को नहीं जानता था। SPLIT_STRING निश्चित रूप से एक लंबी अतिदेय सुविधा है। मैंने विभाजन का उपयोग करके स्क्रिप्ट को नीचे करने की कोशिश की, इसे 174 तक नीचे कर दिया, हालांकि यह "= = =" जैसे पाठ को फ़िल्टर करने में सक्षम नहीं होगा
t-clausen.dk

3

PostgreSQL, 246 , 245 बाइट्स

WITH z AS(SELECT DISTINCT*,COUNT(*)OVER(PARTITION BY t,m)c FROM i,regexp_split_to_table(translate(lower(t),'.,"''',''),E'\\s+')m)
SELECT t,CASE WHEN COUNT(*)>1 THEN '' ELSE MAX(m)END
FROM z WHERE(t,c)IN(SELECT t,MAX(c)FROM z GROUP BY t)
GROUP BY t  

आउटपुट:

यहाँ छवि विवरण दर्ज करें

अगर किसी को दिलचस्पी है तो इनपुट करें:

CREATE TABLE i(t TEXT);

INSERT INTO i(t)
VALUES ('The man walked down the road.'), ('Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.'),
       ('This sentence has no most frequent word.'), ('"That''s... that''s... that is just terrible!" he said. '), ('The old-fashioned man ate an old-fashioned cake.'), 
       ('IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.'), ('a   a            a b b b c');


आम तौर पर मैं उपयोग करता हूं MODE() WITHIN GROUP(...)और यह बहुत छोटा होगा, लेकिन इसका उल्लंघन होगा:

यदि कोई सबसे लगातार शब्द नहीं है (परीक्षण केस # 3 देखें), तो आपके प्रोग्राम को कुछ भी आउटपुट नहीं करना चाहिए।


संपादित करें:

हैंडलिंग ':

WITH z AS(SELECT DISTINCT*,COUNT(*)OVER(PARTITION BY t,m)c FROM i,regexp_split_to_table(translate(lower(t),'.,"!',''),E'\\s+')m)
SELECT t,CASE WHEN COUNT(*)>1 THEN '' ELSE MAX(m)END
FROM z WHERE(t,c)IN(SELECT t,MAX(c)FROM z GROUP BY t)
GROUP BY t  

SqlFiddleDemo

आउटपुट:

╔═══════════════════════════════════════════════════════════════════════════════════════════════╦═══════════════╗
║                                              t                                                ║      max      ║
╠═══════════════════════════════════════════════════════════════════════════════════════════════╬═══════════════╣
║ a a a b b b c                                                                                 ║               ║
║ The old-fashioned man ate an old-fashioned cake.                                              ║ old-fashioned ║
║ IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.  ║ ipv6          ║
║ This sentence has no most frequent word.                                                      ║               ║
║ "That's... that's... that is just terrible!" he said.                                         ║ that's        ║
║ The man walked down the road.                                                                 ║ the           ║
║ Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.        ║ he            ║
╚═══════════════════════════════════════════════════════════════════════════════════════════════╩═══════════════╝

आप के रूप में के रूप में कम नहीं मिल सकता है, sqlserver विभाजन में अभी तक निर्माण नहीं है। हालाँकि चयनित हिस्सा छोटा है।
t-clausen.dk

@GeorgeGibson ज़रूर, फिक्स्ड + जोड़ा लाइव डेमो।
१२:२०

@ lad2025 चैट में आम सहमति से, जो आपने किया वह अब आवश्यक नहीं है, वापस लौटने के लिए स्वतंत्र महसूस करें।
जॉर्ज गिब्सन

@GeorgeGibson Yup, संपादन बहुत स्पष्ट होगा। लाइव डेमो अब काम कर रहा है, जब मैंने उत्तर दिया कि sqlfiddle जवाब नहीं दे रहा था।
लाड 2025

2

आर, 115 बाइट्स

function(s)if(sum(z<-(y=table(tolower((x=strsplit(s,"[^\\w']",,T)[[1]])[x>""])))==max(y))<2)names(which(z))else NULL

यह एक ऐसा फंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग देता है यदि कोई एकल शब्द दूसरों की तुलना में अधिक बार दिखाई देता है और NULLअन्यथा। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

Ungolfed:

f <- function(s) {
    # Create a vector of words by splitting the input on characters other
    # than word characters and apostrophes
    v <- (x <- strsplit(s, "[^\\w']", perl = TRUE))[x > ""]

    # Count the occurrences of each lowercased word
    y <- table(tolower(v))

    # Create a logical vector such that elements of `y` which occur most
    # often are `TRUE` and the rest are fase
    z <- y == max(y)

    # If a single word occurs most often, return it, otherwise `NULL`
    if (sum(z) < 2) {
        names(which(z))
    } else {
        NULL
    }
}

2

रेटिना, 97 बाइट्स

नियम बदलते रहे ...

T`L`l
[^-\w ]

O`[-\w]+
([-\w]+)( \1\b)*
$#2;$1
O#`[-\w;]+
.*\b(\d+);[-\w]+ \1;[-\w]+$

!`[-\w]+$

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

परीक्षण सूट।



@ C @O'Bʀɪᴇɴ धन्यवाद, निश्चित।
लीक नून

1
और आपने इसे 11 बाइट्स के लिए दिया ।_ प्रभावशाली
कॉनर ओ'ब्रायन

इसके अलावा "पुराने जमाने के आदमी ने पुराने जमाने का केक खाया।"
t-clausen.dk

यह या तो सही नहीं लगता है ( aवहाँ सबसे आम शब्द होने की उम्मीद है)
TessellatingHeckler

2

अजगर, 132 बाइट्स

import collections as C,re
def g(s):(a,i),(b,j)=C.Counter(re.sub('[^\w\s-]','',s.lower()).split()).most_common(2);return[a,''][i==j]

उपरोक्त कोड मानता है कि इनपुट में कम से कम दो शब्द हैं।


प्यार करने के लिए समझ गया कि रेक्स, थो।
ब्लू '

यह गलत है। वर्ण वर्ग \wमें अंडरस्कोर शामिल है।
mbomb007

1

PHP, 223 बाइट्स

$a=array_count_values(array_map(function($s){return preg_replace('/[^A-Za-z0-9]/','',$s);},explode(' ',strtolower($argv[1]))));arsort($a);$c=count($a);$k=array_keys($a);echo($c>0?($c==1?$k[0]:($a[$k[0]]!=$a[$k[1]]?$k[0]:'')):'');

1

पायथन 2, 218 बाइट्स

2 से अधिक शब्द मानता है। विराम चिह्न से छुटकारा ने मुझे नष्ट कर दिया ...

import string as z
def m(s):a=[w.lower()for w in s.translate(z.maketrans('',''),z.punctuation).split()];a=sorted({w:a.count(w)for w in set(a)}.items(),key=lambda b:b[1],reverse=1);return a[0][0]if a[0][1]>a[1][1]else''

क्या यह पट्टी ',-आदि?
टिम

@ समय नहीं, नियमों को पूरी तरह से समाप्त करने से पहले मैंने यह चुनौती दी थी। बदल जाएगा।
ब्लू '

क्या आप sortedमैन्युअल रूप से सरणी में अनुक्रमित करने के बजाय टपल का परिणाम निर्दिष्ट कर सकते हैं ?
नील

@ क्या आपको लगता है कि पूरे सरणी के बजाय तुलना के लिए सिर्फ पहला और दूसरा आइटम मिल सकता है? मुझे नहीं पता कि कैसे करना है
ब्लू

1

मतलाब (225)

  • नियमों का उल्लंघन किया गया: /

      function c=f(a),t=@(x)feval(@(y)y(y>32),num2str(lower(x)-0));f=@(x)num2str(nnz(x)+1);e=str2num(regexprep(a,'([\w''-]+)',' ${t($1)} ${f($`)} ${f([$`,$1])}'));[u,r,d]=mode(e);try c=find(e==d{:});c=a((e(c(1)+1)):(e(c(1)+2)));end
  • इसे चलाने के लिए टूलबॉक्स आवश्यक है।

  • यह कैसे काम करता है, रेगेक्स के सबसे अच्छे विशेषाधिकारों में से एक matlab में बदल जाता है, यह क्षेत्र-बाहरी टोकन को कॉल करता है, जिसे आंतरिक वातावरण में पकड़े गए टोकन द्वारा परिचालित बाहरी-पर्यावरणीय कार्यों को कॉल किया जाता है, इसलिए किसी भी अनुक्रम को "Word_A Word_B .."पूर्णांक द्वारा प्रतिस्थापित किया जाता है "A0 A1 A2 B0 B1 B2 ..."जहां पहला पूर्णांक होता है शब्द के numerica ascii हस्ताक्षर, दूसरी शुरू सूचकांक है, तीसरे समाप्त होने के सूचकांक, इन पिछले दो पूर्णांकों पूरे अनुक्रम में न दोहरा देना तो मैं इस फायदा उठाया एक सरणी के लिए इसे स्थानांतरित करने के लिए है, तो मोड यह तो खोज परिणाम उस सरणी में है, इसलिए आरंभिक / समाप्ति सूचक परिणाम देगा।

  • संपादित करें: कुछ विवरणों को बदलने के बाद, प्रोग्राम को एक स्ट्रिंग पैरामीटर द्वारा फ़ंक्शन कहा जाता है।


20 बाइट्स @StewGriffin की बदौलत बच गईं, 30 बाइट्स ने आम-सहमति वाली खामियों के लिए रिपॉर्च जोड़ दिया।


जब आप (या कोई और) यह दिखाता है कि यह वास्तव में काम करता है, तो दोनों इनपुट्स के लिए सबसे सामान्य शब्द है, और उन इनपुट्स के लिए जो नहीं करते हैं। =) (मैं इसका परीक्षण नहीं कर सकता, दुर्भाग्य से)
स्टीवी ग्रिफिन

@StewieGriffin मुझे लगता है कि समान-शब्द के साथ वाक्यों के साथ दुर्व्यवहार गलत होता है, मैं इसे ठीक कर
दूंगा

1

05AB1E , 22 21 20 बाइट्स

žK„- JÃl#{D.MDgiJëõ?

स्पष्टीकरण:

žK                     # Push [a-zA-Z0-9]
  „-                   # Push 2-char string containing a hyphen and a space
     J                 # Join the stack into a single element
      Ã                # Removes all characters from implicit input except those specified above
       l               # Converts to lowercase
        #              # Split string by spaces
         {             # Sorts array
          D            # Duplicates
           .M          # Finds most common element
             Dg        # Gets length of string without popping
                 iJ    # If length == 1, then convert the array to a string (otherwise the output would be ['example'] instead of example
                   ëõ? # Else push an empty string.

नोट: यदि आप आउटपुट में newlines के साथ ठीक हैं, जब आप कुछ भी उत्पादन करने के लिए नहीं हैं, तो ?बाइट को बचाने के लिए अंत में निकालें ।

नोट # 2: कार्यक्रम एक शब्द के साथ काम नहीं करेगा, लेकिन मुझे संदेह है कि यह एक समस्या होगी। यदि आप इसे ठीक करना चाहते हैं, तो एक अतिरिक्त बाइट के #साथ बदलें ð¡

05AB1E CP-1252 को चारसेट के रूप में उपयोग करता है, UTF-8 को नहीं।

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


1

पर्ल, 60 56 55 54 बाइट्स

के लिए +3 शामिल है -p

#!/usr/bin/perl -p
s/[\pL\d'-]+/$;[$a{lc$&}++]++or$\=$&/eg}{$\x=2>pop@

यदि कोई शब्द सिर्फ एक संख्या नहीं हो सकता है तो आप a53 के स्कोर के लिए भी ड्रॉप कर सकते हैं ।


क्या हाइफ़न की -anEगिनती नहीं है? यह अन्य उत्तर ( -pध्वज के लिए +2 बाइट्स ) पर करता है ...
जॉर्ज गिब्सन

@GeorgeGibson नहीं, meta.codegolf.stackexchange.com/questions/273/… देखें । हाइफ़न, स्थान और Eगिनती नहीं है। अन्य उत्तर के लिए सामान्य रूप से केवल +1 बाइट्स के लिए करना होगा -p, लेकिन उसका समाधान 'ऐसा है कि इसे -eया के विस्तार के रूप में नहीं देखा जा सकता है -E। इसलिए उसे वास्तव में +3 (+2 नहीं) गिनना चाहिए क्योंकि उसे अंतरिक्ष और हाइफन की गणना करनी चाहिए (लेकिन हर अतिरिक्त विकल्प केवल +1 होगा)।
टन हास्पेल

@ टॉमहोम ओह, सही है।
जॉर्ज गिब्सन

क्या इसे वैध नियम मान दिया गया है? [\pL\d-]ऐसा लगता है कि इसे नीचे [\w-]तक छोटा किया जा सकता है (जब तक कि हम अंडरस्कोर की परवाह नहीं करते हैं) लेकिन या तो संस्करण 4 के thatबजाय that'sया thatsपरीक्षण के लिए रिपोर्ट करेगा । अन्यथा, आपको \x27उस चरित्र वर्ग में सम्मिलित करने के लिए 4 बाइट्स जोड़ने की आवश्यकता है (जब तक कि आपको जोड़ने का एक बेहतर तरीका न हो a apostrophe)।
एडम काटज

@AdamKatz 'शब्द' की परिभाषा थोड़ी बहुत बदल गई, जबकि यह चल रहा था और मैंने कभी भी अंतिम संस्करण को पूरी तरह से नहीं अपनाया। लेकिन आपको खुश रखने के लिए मैंने एक निश्चित (और कम) संस्करण :-) बनाया। और हाँ, मैं अंडरस्कोर के बारे में परवाह करता हूं
टन हास्पेल

0

पॉवरशेल (v4), 117 बाइट्स

$y,$z=@($input-replace'[^a-z0-9 \n-]'-split'\s'|group|sort Count)[-2,-1]
($y,($z,'')[$y.Count-eq$z.Count])[!!$z].Name

पहला भाग काफी आसान है:

  • $input ~ ~ है
  • रेगेक्स अप्रासंगिक पात्रों को कुछ नहीं के साथ बदल देता है, नई सुर्खियों में रहता है इसलिए हम एक पंक्ति के अंत से दो शब्दों को नहीं मिटाते हैं और अगली पंक्ति की शुरुआत गलती से करते हैं। (किसी और ने कई लाइनों पर चर्चा नहीं की है, क्या गोल्फ -2 अगर इनपुट हमेशा एक ही लाइन हो सकता है)।
  • रेगेक्स विभाजन, Groupआवृत्ति द्वारा (~ = पायथन के संग्रह। मुठभेड़), Sortअंत में सबसे अधिक बार शब्दों को रखने के लिए।
  • PowerShell हर चीज के लिए डिफ़ॉल्ट रूप से असंवेदनशील है।

अगर बार-बार कोई शब्द नहीं है तो हैंडलिंग:

  • $ Y और $ z में अंतिम दो आइटम [-2, -1] लें;
  • एक N- आइटम सूची, जहाँ N> = 2, $ y और $ z अंतिम दो आइटम बनाती है
  • 1-आइटम सूची $ y को अंतिम आइटम और $ z नल बनाती है
  • एक खाली सूची उन दोनों को अशक्त बनाती है

(0,1)[truthyvalue]"-", $ z या $ y को आउटपुट के रूप में चुनने के लिए बूल-अस-एरे-इंडेक्स फर्जी-टर्नरी-ऑपरेटर गोल्फ का उपयोग करें, फिर नाम लें।

PS D:\> "The man walked down the road."|.\test.ps1
The

PS D:\> "Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy."|.\test.ps1
he

PS D:\> "`"That's... that's... that is just terrible!`" he said."|.\test.ps1
Thats

PS D:\> "The old-fashioned man ate an old-fashioned cake."|.\test.ps1
old-fashioned

PS D:\> "IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses."|.\test.ps1
IPv6

0

लुआ, 232 199 175 बाइट्स

w,m,o={},0;io.read():lower():gsub("[^-%w%s]",""):gsub("[%w-]+",function(x)w[x]=(w[x]or 0)+1 end)for k,v in pairs(w)do if m==v then o=''end if(v>m)then m,o=v,k end end print(o)

1
if not w[x]then w[x]=0 end w[x]=w[x]+1 end->w[x]=(w[x]or0)+1
लीक नन

if m==v then o=''end->o=m==v and '' or o
लीक नून

0

पर्ल 5, 96 92 84 + 2 ( -pध्वज) = 86 बाइट्स

++$h{+lc}for/\w(?:\S*\w)?/g}{$m>$e[1]||$e[1]>$m&&(($_,$m)=@e)||($_="")while@e=each%h

का उपयोग करते हुए:

> echo "The man walked down the road." | perl -p script.pl

आपके -pध्वज को 3 बाइट्स का जुर्माना देना चाहिए। नियम मोटे तौर पर हैं: प्रत्येक कमांडलाइन ध्वज +1 बाइट है, क्योंकि आपको अपनी फ्री -e'code'स्टाइल कमांडलाइन को बढ़ाने के लिए कितने अतिरिक्त बाइट्स की आवश्यकता है । तो आम तौर -pपर केवल +1 बाइट है। लेकिन यहां आपका कोड है, 'इसलिए इसे बिना भागने के केवल कमांडलाइन से नहीं चलाया जा सकता है। तो अतिरिक्त के साथ -eऔर -स्थान के साथ कोई संयोजन नहीं है pऔर इसे भी गिना जाना चाहिए
टन हास्पेल

@ टोनहोस्ट फिक्स्ड।
डेनिस इबाएव

यह वास्तव में 84 + 1 ( -pध्वज) है अगर आप इसे कमांड लाइन पर लागू करते हैं perl -pe'…'( 'जैसा कि पहले टिप्पणियों में नोट किया गया है) उपलब्ध कराया गया है
एडम काट्ज

0

पायथन, 158 बाइट्स

def g(s):import collections as c,re;l=c.Counter(re.sub('[^\w\s-]',"",s.lower()).split());w,f=l.most_common(1)[0];return[w,""][all(f==i[1]for i in l.items())]

इसका इनपुट इस तरह लेता है:

g("Bird is the word")

सभी आवश्यकताओं से मेल खाना चाहिए, हालांकि यह खाली तारों पर विफल रहता है, क्या उन लोगों के लिए जांच करना आवश्यक है? विलंब के लिए क्षमा चाहते हैं।

बाइट्स बचाने के लिए सलाह / प्रतिक्रिया / काला जादू युक्तियाँ हमेशा स्वागत योग्य हैं


नमस्ते, और PPCG में आपका स्वागत है! हम जवाब में बाइट्स की संख्या से कोड-गोल्फ चुनौतियों का सामना करते हैं। मैंने आगे बढ़कर इसे सही जानकारी के साथ आपके लिए संपादित किया।
R

2
PPCG में आपका स्वागत है! दुर्भाग्य से, आपका प्रस्तुतिकरण इस चुनौती की सभी आवश्यकताओं को पूरा नहीं करता है, सबसे पहले, यह असंवेदनशील नहीं है। उदाहरण के लिए, यह शब्द की घटनाओं को शब्द की Thatघटनाओं के रूप में नहीं गिना जाएगा thatक्योंकि पूर्व एक अपरकेस से Tशुरू होता है और बाद में एक लोअरकेस के साथ शुरू होता है t। इसके अलावा, यह हाइफ़न ( -) और, वैकल्पिक रूप से, एपोस्ट्रोफ़ ( ') को छोड़कर विराम के अन्य सभी रूपों को नहीं हटाता है और परिणामस्वरूप, यह प्रश्न में दिए गए चौथे परीक्षण मामले के लिए काम नहीं करेगा।
आर। काप

1
इसके अलावा, यह कुछ भी नहीं उत्पादन अगर वहाँ कोई सबसे लगातार शब्द है। उदाहरण के लिए, This sentence has no most frequent word.एक उदाहरण के रूप में तीसरे परीक्षण मामले ( ) का उपयोग करते हुए , आपका फ़ंक्शन आउटपुट करता है [('This', 1)], जब इसके बजाय कुछ भी आउटपुट नहीं होना चाहिए। मैं और अधिक मुद्दों के बारे में आगे बढ़ सकता हूं, इसलिए मैं उन्हें जल्द से जल्द ठीक करने की सलाह दूंगा।
आर। काप

जल्द ही करेंगे, जब मेरे पास समय
होगा

यह गलत है। वर्ण वर्ग \wमें अंडरस्कोर शामिल है।
mbomb007

0

Tcl 8.6, 196 बाइट्स

lmap s [join [read stdin] \ ] {dict incr d [regsub -all {[^\w-]} [string tol $s] {}]}
set y [dict fi $d v [lindex [lsort [dict v $d]] end]]
if {[llength $y]!=2} {set y {}}
puts "==> [lindex $y 0]"

(काश, मैं यह पता नहीं लगा सकता कि इसे इससे छोटा कैसे पाया जाए ...)

व्याख्या

यह सामान करने के लिए कई अस्पष्ट Tcl मुहावरों का उपयोग करता है।

  • [join [read stdin] " "] - इनपुट स्ट्रिंग → व्हॉट्सएप-अलग-अलग शब्दों की सूची
  • lmap ... - उस सूची के प्रत्येक तत्व पर पुनरावृति। ( foreachपरिणाम खारिज होने के बाद से और प्रभावी रूप से समान रूप से छोटा ।)
  • [regsub ... [string tolower ...]] - शब्द वर्णों और हाइफ़न को छोड़कर सभी वर्णों को कम करने और पट्टी करने के लिए स्ट्रिंग में कनवर्ट करें।
  • [dict incr d ...] - शब्दकोश / शब्द बनाना / बदलना → हिस्टोग्राम गिनना।
  • set y ... - शब्दकोश मूल्यों को क्रमबद्ध करें, सबसे बड़ा एक लें, और सभी (कुंजी, मूल्य) जोड़े को इसके अनुरूप लौटाएं।
  • if... - बिल्कुल दो तत्व होने चाहिए: एक एकल (कुंजी, मूल्य) जोड़ी, अन्यथा प्रिंट करने के लिए कुछ भी नहीं है।
  • puts... - कुंजी मूल्य जोड़ी में कुंजी प्रिंट करें, यदि कोई हो। (कोई शब्द रिक्त स्थान नहीं है।)

आप CodeChef का उपयोग करके इसके साथ खेल सकते हैं ।



0

Rexx, 109 128 122 बाइट्स

pull s;g.=0;m=0;do i=1 to words(s);w=word(s,i);g.w=g.w+1;if g.w>=m then do;m=g.w;g.m=g.m+1;r=w;end;end;if g.m=1 then say r

बहुत मुद्रित ...

pull s
g.=0
m=0
do i=1 to words(s)
  w=word(s,i)
  g.w=g.w+1
  if g.w>=m
  then do
    m=g.w
    g.m=g.m+1
    r=w
  end
end
if g.m=1 then say r

मुझे नहीं लगता कि यह बंधे हुए शब्दों के सभी मामलों को संभालता है - देखें (नया) अंतिम परीक्षण मामला - मैंने ऐसी ही गलती की।
दर्शनशास्त्र १५'१६

उम्मीद है, यह अब तय हो गया है
आजा

0

बाश, 153 146 131 154 149 137 बाइट्स

declare -iA F
f(){ (((T=++F[$1])==M))&&I=;((T>M))&&M=$T&&I=$1;}
read L
L=${L,,}
L=${L//[^- a-z0-9]}
printf -vA "f %s;" $L
eval $A;echo $I

ऑपरेशन:

पूर्णांक की एक साहचर्य सारणी घोषित करें (घोषणा-एफए एफ)

f एक ऐसा फंक्शन है, जिसे एक शब्द पैरामीटर $ 1 दिया गया है, इस शब्द के लिए इंक्रीमेंट फ्रीक्वेंसी काउंट (T = ++ F [$ 1]) है और अब तक की अधिकतम गणना की तुलना करता है (M)।

यदि बराबर है, तो हमारे पास एक टाई है इसलिए हम इस शब्द को सबसे अधिक बार नहीं मानेंगे (I =)

यदि अब तक (M) की अधिकतम गणना से अधिक है, तो इस शब्द की आवृत्ति गणना के लिए अब तक अधिकतम संख्या निर्धारित करें (M = $ T) और इस शब्द को याद रखें (I = $ 1)

अंत समारोह एफ

एक पंक्ति पढ़ें (L पढ़ें) लोअरकेस बनाएं (L = $ {L ,,}) az, 0-9, डैश (-) और स्पेस (L = $ {L // [^ - a-z0-) को छोड़कर किसी भी वर्ण को हटा दें। 9]}) बैश स्टेटमेंट का एक क्रम बनाएं जो प्रत्येक शब्द के लिए f को प्रिंट करता है (printf -vA "f% s;" $ L)। यह चर ए। एवल ए और प्रिंट रिजल्ट (eval $ a; echo $ I) से बचा है

आउटपुट:

This quick brown fox jumps over this lazy dog.
-->this
This sentence with the words has at most two equal most frequent the words.
-->
The man walked down the road.
-->the
This sentence has no most frequent word.
-->
Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.
-->he
"That's... that's... that is just terrible!" he said.
-->thats
The old-fashioned man ate an old-fashioned cake.
-->old-fashioned
IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.
-->ipv6

बग: फिक्स्ड मेरे पास एक बग है जो इन परीक्षण मामलों में सामने नहीं आया है। अगर इनपुट है

This sentence with words has at most two equal most frequent words.

तो मेरा कोड कुछ भी नहीं उत्पादन करना चाहिए।

मेरे पास एक फिक्स है, लेकिन मुझे लगता है कि एक बैश बग मारा है ... मुझे बहुत अजीब व्यवहार मिलता है एम को पूर्णांक घोषित नहीं किया जाता है: ++ एफ [$ 1] == एम (कुछ दोहराया शब्दों के बाद) दोनों एफ [$ 1 ] और एम !! - मेरी गलती।


0

पायथन 3, 76 98 100 बाइट्स

import re,statistics as S
try:print(S.mode(re.split("([a-z0-9-]+)",input().lower())[1::2]))
except:1

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

सबसे आम शब्द को लोअरकेस के रूप में आउटपुट करता है। इसमें एपोस्ट्रोफ शामिल नहीं है क्योंकि "एपोस्ट्रोफ को शामिल करने की आवश्यकता नहीं है।"

statistics.mode पायथन 3.4 की आवश्यकता है

दुर्भाग्य से, कोई आउटपुट stderrकी अनुमति नहीं है, या यह बहुत कम होगा।


STDERRजब तक यह कार्यक्रम किसी भी त्रुटि आउटपुट का उत्पादन नहीं करता है, तब तक आपको प्रिंट करने की अनुमति नहीं है
ओकेक्स

आपका नया कार्यक्रम हाइफ़न का समर्थन नहीं करता है! मैंने इनपुट की कोशिश कीi- test i-
Okx

यह सब तय किया। अभी भी कम है।
mbomb007

0

आर, 96 बाइट्स

19 बाइट्स मौजूदा आर उत्तर की तुलना में कम है , कुछ अलग दृष्टिकोण के साथ।

t=table(gsub("[^a-z0-9'-]","",tolower(scan(,''))))
`if`(sum(t==max(t))-1,'',names(which.max(t)))

स्टड से पढ़ता है, इसलिए इनपुट स्वचालित रूप से रिक्त स्थान से अलग हो जाता है। हम gsubसभी गैर-अल्फ़ान्यूमेरिक्स (प्लस -और ') को हटाने के लिए लोअरकेस और उपयोग में कनवर्ट करते हैं । हम प्रत्येक शब्द के उदाहरणों को गिनते हैं tableऔर परिणाम को बचाते हैं t। इसके बाद, हम जांचते हैं कि क्या इसमें 1 से अधिक अधिकतम है t(यह देखकर कि क्या एक से अधिक तत्व है जो बराबर है max(t)। यदि हां, तो हम खाली स्ट्रिंग लौटाते हैं ''। यदि नहीं, तो हम अधिकतम में इसी शब्द को वापस करते हैं t

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.