सीलोन 386 333 252 230 222 216 171 153 131 111
String t(String s,Integer l)=>s.size<l then s else s[0:(s[0:l-2].lastIndexWhere(" -".contains)else l-3)]+"...";
अधूरा मूल:
String truncate(String text, Integer length) {
if(text.size < length) {
return text;
}
Boolean spacePredicate(Character char) {
return char == ' ' || char == '-';
}
Integer? spaceIndex = text[0:length-2].lastIndexWhere(spacePredicate);
if(exists spaceIndex) {
return text[0:spaceIndex] + "...";
}
return text[0:length-3]+"...";
}
यह 386 बाइट्स / वर्ण है। यहाँ कुछ दिलचस्प विशेषताएं:
x[y:z]वाक्य रचना के लिए वाक्यात्मक चीनी है x.measure(y, z), और की एक subrange रिटर्न xपर शुरू yलंबाई के साथ z- स्ट्रिंग्स के लिए, यह एक स्ट्रिंग है। (वहाँ भी है x[y..z]वाक्य रचना, एक है जो काल z करने के लिए सूचकांक y से, दोनों समावेशी है, साथ ही आधा खुला फैला x[...z]और x[y...]।)
List.lastIndexWhereएक विधेय लेता है (यानी एक सूची तत्व लेने वाला एक समारोह और एक बूलियन, यानी यहां Callable<Boolean, [Character]>) वापस लौटता है , और अंतिम सूची तत्व का सूचकांक देता है जहां विधेय पूरा होता है (या अशक्त, अगर यह कभी पूरा नहीं होता है)। जैसा कि तार सूची हैं, यह तार के लिए भी काम करता है।
इसका परिणाम, spaceIndexप्रकार का है Integer|Null, या Integer?संक्षिप्त रूप से है - अर्थात यह या तो एक पूर्णांक या nullकेवल प्रकार का मान हो सकता है Null। (नाम spaceIndexतब आता है जब मुझे एहसास नहीं था कि -यह भी विशेष था - मुझे लगता है breakIndexकि बेहतर होगा।)
साथ exists spaceIndexहम देख सकते हैं कि spaceIndexहै गैर-शून्य, और कुछ अलग तो है। (इसके अंदर अगर संकलक जानता है कि यह गैर-अशक्त है ... तो इसके बिना अगर मुझे spaceIndexस्ट्रिंग का उपयोग करने की शिकायत होती, तो वह शिकायत करता।)
स्थानीय फ़ंक्शन के बजाय spacePredicateहम एक अनाम फ़ंक्शन का भी उपयोग कर सकते हैं
(Character char) => char == ' ' || char == '-'
यह हमें 333 अक्षरों में लाता है:
String truncate(String text, Integer length) {
if(text.size < length) {
return text;
}
Integer? spaceIndex = text[0:length-2].lastIndexWhere(
(Character char) => char == ' ' || char == '-');
if(exists spaceIndex) {
return text[0:spaceIndex] + "...";
}
return text[0:length-3]+"...";
}
अगला अनुकूलन छोटे चर और फ़ंक्शन नामों का उपयोग करना है, जो हमें 81 बाइट्स से 252 तक लाता है:
String t(String s, Integer l) {
if(s.size < l) {
return s;
}
Integer? i = s[0:l-2].lastIndexWhere(
(Character e) => e == ' ' || e == '-');
if(exists i) {
return s[0:i] + "...";
}
return s[0:l-3]+"...";
}
विधेय फ़ंक्शन को वास्तव में घोषित किए गए अपने तर्क प्रकार की आवश्यकता नहीं है, जिसे कंपाइलर द्वारा अनुमान लगाया जा सकता है। उसी प्रकार के लिए i(जहां हमें अभी भी valueइसे एक घोषणा के रूप में चिह्नित करने के लिए लिखना है)। अब यह घोषणा एक पंक्ति में फिट होने के लिए काफी कम है, हमें 230 पर लाती है:
String t(String s, Integer l) {
if(s.size < l) {
return s;
}
value i = s[0:l-2].lastIndexWhere((e) => e == ' ' || e == '-');
if(exists i) {
return s[0:i] + "...";
}
return s[0:l-3]+"...";
}
इसके बजाय e == ' ' || e == '-'हम यह भी लिख सकते हैं e in [' ', '-'](या e in {' ', '-'}, यह एक टपल एक के बजाय एक चलने योग्य कंस्ट्रक्टर है)। inऑपरेटर विधि Category.contains है, जो हमें विचार करने के लिए लाता है कि हम उस टपल के पास कर सकते हैं करने के लिए नक्शे containsविधि सीधे (यह एक प्रतिदेय है किसी भी वस्तु ले रही है, तो भी चरित्र को स्वीकार करने), बिना (e) => ...बॉयलरप्लेट (222 बाइट्स):
String t(String s, Integer l) {
if(s.size < l) {
return s;
}
value i = s[0:l-2].lastIndexWhere([' ', '-'].contains);
if(exists i) {
return s[0:i] + "...";
}
return s[0:l-3]+"...";
}
दरअसल, एक ही श्रेणी जिसमें दो वर्ण होते हैं, वह दो-वर्ण स्ट्रिंग है " -"। (इसके अलावा इसमें इसका सबस्ट्रिंग भी शामिल है, लेकिन यहाँ चोट नहीं लगती है)। 216 बाइट्स।
String t(String s, Integer l) {
if(s.size < l) {
return s;
}
value i = s[0:l-2].lastIndexWhere(" -".contains);
if(exists i) {
return s[0:i] + "...";
}
return s[0:l-3]+"...";
}
मुझे लगता है कि हम इस पंक्ति से सबसे अधिक बाहर निकल गए हैं, चलो दूसरों की ओर मुड़ते हैं ... पिछले दो रिटर्न स्टेटमेंट में कुछ समानता है जो हम शोषण कर सकते हैं - वे बस iबनाम में भिन्न l-3हैं, और iबस का उपयोग कर रहे हैं जब यह अशक्त नहीं है, अन्यथा l-3। सौभाग्य से यह वास्तव में क्या हैelse ऑपरेटर के लिए बनाया गया है!
String t(String s, Integer l) {
if(s.size < l) {
return s;
}
value i = s[0:l-2].lastIndexWhere(" -".contains);
return s[0:(i else l-3)] + "...";
}
(कोष्ठक यहाँ आवश्यक प्रतीत होते हैं, जैसा कि elseपहले की तुलना में कम है [:]।) यह 171 वर्ण है। अभी वi बस एक बार उपयोग किया जाता है, इसलिए हम इसे इनलाइन कर सकते हैं, हमें 153 वर्णों में ला सकते हैं:
String t(String s, Integer l) {
if(s.size < l) {
return s;
}
return s[0:(s[0:l-2].lastIndexWhere(" -".contains) else l-3)] + "...";
}
हम इस if-return-returnसंयोजन को एक में ऑपरेटरों thenऔर elseऑपरेटरों के संयोजन से भी बदल सकते हैं return। ( thenरिटर्न दूसरा ऑपरेंड है जब पहला सच है, अन्यथा अशक्त है, जो तब अनुमति देता हैelse अपने दूसरे ऑपरेंड को वापस करने की है। `) 131 बाइट्स (हालांकि कुछ बचत सफेद रिक्त स्थान हैं जो हम किसी भी रास्ते से छुटकारा पा लेंगे):
String t(String s, Integer l) {
return s.size < l then s else s[0:(s[0:l-2].lastIndexWhere(" -".contains) else l-3)] + "...";
}
एक फ़ंक्शन जिसमें अभिव्यक्ति के साथ सिर्फ एक रिटर्न होता है, वैकल्पिक रूप से "वसा तीर" संकेतन के साथ लिखा जा सकता है, 123 दे रहा है:
String t(String s, Integer l) =>
s.size < l then s else s[0:(s[0:l-2].lastIndexWhere(" -".contains) else l-3)] + "...";
अनावश्यक व्हाट्सएप को हटाने से हमें अंतिम 111 बाइट मिलती हैं:
String t(String s,Integer l)=>s.size<l then s else s[0:(s[0:l-2].lastIndexWhere(" -".contains)else l-3)]+"...";
इसके अतिरिक्त, यहां एक फ़ंक्शन है जो प्रश्न से उदाहरणों को प्रिंट करता है ( tचरण दो के बाद नाम का उपयोग किया जाता है):
shared void testTruncate() {
value testInputs = {
["This is some very long text.", 25],
["This-is-some-long-hyphen-separated-text.", 33],
["Programming Puzzles & Code Golf is a question and answer site for programming puzzle enthusiasts and code golfers.", 55],
["abcdefghijklmnopqrstuvwxyz", 20],
["a b c", 4],
["Very long.", 100]
};
for(input in testInputs) {
print(t(*input));
}
}