Monday Mini-Golf:ชุดของความท้าทายรหัสสั้น ๆกอล์ฟโพสต์ (หวังว่า!) ทุกวันจันทร์

แอปพลิเคชั่นเว็บหลายแห่ง (โดยเฉพาะสื่อสังคมออนไลน์) จะตัดข้อความที่มีความยาวโดยอัตโนมัติเพื่อให้พอดีกับการจัดรูปแบบของแอป ในความท้าทายนี้เราจะสร้างอัลกอริทึมเพื่อตัดข้อความโดยอัตโนมัติตามความยาวที่กำหนด

ท้าทาย

เป้าหมายของการท้าทายคือการเขียนโปรแกรมหรือฟังก์ชั่นที่มีสองข้อโต้แย้ง:

• Tข้อความที่จะตัดทอน
• Lความยาวสูงสุดที่จะคืน

และส่งคืนTถูกตัดทอนด้วยตรรกะต่อไปนี้:

• หากความยาวของTน้อยกว่าหรือเท่ากับLไม่จำเป็นต้องตัดทอน ส่งคืนสตริงเดิม
• ตัดTถึงความยาวL -2 ถ้าเรื่องนี้ไม่มีช่องว่างหรือยัติภังค์กลับTตัดทอนให้ตรงL -3 ...ตัวอักษรตามด้วยจุดไข่ปลา
• มิฉะนั้นให้ตัดส่วนท้ายของผลลัพธ์จนถึงช่องว่างสุดท้ายหรือเครื่องหมายขีดกลาง เพิ่มจุดไข่ปลา...และกลับผลลัพธ์

รายละเอียด

• TและLอาจถูกดำเนินการตามลำดับและรูปแบบใดก็ได้
• คุณอาจจะคิดว่า 3 < L <2 วันที่ 31
• คุณไม่สามารถใช้จุดไข่ปลาแนวนอน U + 2026 …; คุณต้องใช้สามช่วงเวลา
• อินพุตจะไม่เริ่มต้นด้วยเว้นวรรคหรือยัติภังค์
• อินพุตจะไม่มีช่องว่างใด ๆ นอกเหนือจากช่องว่างปกติ (ไม่มีแท็บบรรทัดใหม่ ฯลฯ )

การทดสอบกรณี

ปัจจัยการผลิต:

"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

ขาออก:

"This is some very long..."
"This-is-some-long-hyphen..."
"Programming Puzzles & Code Golf is a question and..."
"abcdefghijklmnopq..."
"a..."
"Very long."

(โปรดทราบว่าเครื่องหมายคำพูดเป็นเพียงเพื่อระบุว่าสิ่งเหล่านี้เป็นสตริงพวกเขาไม่จำเป็นต้องรวม)

เกณฑ์การให้คะแนน

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่ถูกต้องสั้นที่สุดในหน่วยไบต์ชนะ Tiebreaker ไปที่การส่งที่ถึงจำนวนไบต์สุดท้ายก่อน ผู้ชนะจะได้รับเลือกในวันจันทร์ที่ 5 ต.ค. โชคดี!

แก้ไข:ขอแสดงความยินดีกับผู้ชนะของคุณ @Jakube ด้วย Pyth อีกครั้งด้วย25 ไบต์!

Pyth, 25 ไบต์

+WnzK<zeo}@zN" -"-Q2K"...

ลองใช้ออนไลน์: การสาธิตหรือชุดทดสอบ

คำอธิบาย:

+WnzK<zeo}@zN" -"-Q2K"...  implicit: z = input string, Q = input number
        o        -Q2       order the indices N in [0, 1, ..., Q-3] by
         }@zN" -"            z[T] in " -"
                           (hyphen-indices get sorted to the back)
       e                   take the last such number
     <z                    reduce z to length ^
    K                      save this string to K
+WnzK               K"...  print (K + "...") if z != K else only K

Perl, 69 59 52 ไบต์

รหัส 51 ไบต์ + 1 บรรทัดคำสั่งไบต์ ถือว่าอินพุตตัวเลขได้รับอนุญาตให้ใช้กับพารามิเตอร์ -i

s/.{$^I}\K.*//&&s/(^([^ -]*).|.*\K[ -].*)..$/$2.../

การใช้งาน:

echo "This-is-some-long-hyphen-separated-text." | perl -p -i"33" entry.pl

Python 2, 78 73 ไบต์

t,l=input()
u=t[:l-2]
print(t,u[:max(map(u.rfind,' -'))]+'...')[l<len(t)]

รูปแบบอินพุตตามหลังอินพุตตัวอย่าง

JavaScript (ES6), 123 78 67 61 ไบต์

ฉันไม่ได้คาดหวังว่าจะสามารถลดขนาดนี้ได้มากนัก แต่ปรากฎว่าคำสั่ง splice / replace สามารถครอบคลุมทุกกรณีที่จำเป็นต้องมีการตัดปลาย

(T,L)=>T[L]?T.slice(0,L-2).replace(/([ -][^ -]*|.)$/,'...'):T

อาร์กิวเมนต์แรกคือสตริงที่สองคือความยาว ขอบคุณเป็นพิเศษสำหรับ edc65 สำหรับการเพิ่มประสิทธิภาพการตรวจสอบความยาว!

นี่คือรหัสดั้งเดิม (123 ไบต์):

(T,L)=>(T.length>L?(S=T.slice(0,L)).slice(0,(m=Math.max(S.lastIndexOf` `,S.lastIndexOf`-`))<0?L-3:Math.min(L-3,m))+'...':T)

TI-BASIC, 87 ไบต์

Prompt L,Str1
For(X,1,L
{inString(Str1," ",X),inString(Str1,"-",X
max(I,max(Ans*(Ans≤L-3->I
End
Str1
If L<length(Ans
sub(Ans,1,I+(L-3)not(I))+"...
Ans

TI-BASIC ไม่มีคำสั่งการจัดการสตริงจำนวนมากดังนั้นเราจำเป็นต้องค้นหาดัชนีสุดท้ายด้วยตนเอง: หากสตริงไม่มีสตริงที่ต้องการค้นหาinString(ส่งคืน 0 เราค้นหายัติภังค์และช่องว่างที่เริ่มต้นทุกตำแหน่งจาก 1 ไปและบันทึกจำนวนมากที่สุดน้อยกว่าหรือเท่ากับL L-3หากตัวเลขIนั้นยังคงเป็น 0 เราจะใช้L-3เป็นดัชนีสิ้นสุดแทน

เนื่องจากข้อ จำกัด ของเครื่องคิดเลขดัชนีที่ใหญ่ที่สุดของสตริงคือ 9999 ดังนั้นสิ่งนี้จะล้มเหลวสำหรับสตริงขนาดใหญ่

ฉันใช้พฤติกรรมของเครื่องคิดเลขในการเริ่มต้นตัวแปรโดยอัตโนมัติIให้เป็น 0 ดังนั้นลบIหรือล้างหน่วยความจำของเครื่องคิดเลขของคุณก่อนที่จะทำงาน

C # .NET, 187 169 ไบต์

อืม ...

string f(string T,int L){if(T.Length<=L)return T;T=T.Substring(0,L-2);return T.Substring(0,T.Contains(" ")||T.Contains("-")?T.LastIndexOfAny(new[]{' ','-'}):L-3)+"...";}

Python 2, 105 ไบต์

def t(s,l):a=s[:l-2];return s[:max(a.rfind(' '),a.rfind('-'))]+'...'if' 'in a or'-'in a else a[:-1]+'...'

เรียกได้ว่ามี

>>> print t("This is some very long text.", 25)
This is some very long...

Groovy ขนาด 95 ไบต์

a={T,L->F=T.size()<=L?T:T[0..L-3]
m=F=~'(.*[- ])'
F==T?F:m?m[0][0].trim()+'...':F[0..-2]+'...'}

ตรงไปตรงมาสวยอาจจะสามารถเล่นกอล์ฟต่อไป

CJam, 34 ไบต์

q~1$<_@={-2<_W%{" -"&}#~We|<'.3*}|

ลองใช้งานออนไลน์: Chrome | Firefox

T-SQL, 145 ไบต์

create proc a(@t varchar(max),@l int)as if LEN(@t)<=@l return @t;set @t = LEFT(@t,@l-3) select LEFT(@t,LEN(@t)-CHARINDEX('-',REVERSE(@t)))+'...'

การใช้งาน:

exec a("This is some very long text.", 25) exec a("This-is-some-long-hyphen-separated-text.", 33)

อาร์เอส , 116

(\d+)$/(_)^^(\1)
___$/
\t
+\t(.)(.*) (_)(_*)$/\1\t\2 \4
\t(.*?)_+$/\1\t
\t( ?).+/\1
[- ][^- \t]*$/
(?<!\t)$/...
 \t/

อย่างน้อยก็สั้นกว่า C # ...

กรณีสาธิตและการทดสอบสด

Ceylon 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)]+"...";

Ungolfed Original:

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]ไวยากรณ์ซึ่งเป็นช่วงจากดัชนี y ถึง z ทั้งแบบรวมและครึ่งเปิดx[...z]และx[y...].)

List.lastIndexWhereใช้เพรดิเคต (เช่นฟังก์ชันที่รับอิลิเมนต์อิลิเมนต์และส่งคืนบูลีนเช่นที่นี่ a Callable<Boolean, [Character]>) และให้ดัชนีของอิลิเมนต์รายการสุดท้ายที่เพรดิเคตเป็นจริง (หรือเป็นโมฆะ ในฐานะที่เป็นสตริงเป็นรายการสิ่งนี้ก็ใช้ได้กับสตริงด้วยเช่นกัน

ผลลัพธ์ของสิ่งนี้spaceIndexเป็นประเภทInteger|NullหรือInteger?สั้น - นั่นคือสามารถเป็นจำนวนเต็มหรือnull(ค่าชนิดNullเท่านั้น) (ชื่อspaceIndexมาจากเมื่อฉันไม่ทราบว่า-เป็นพิเศษ - ฉันเดาว่าbreakIndexจะดีกว่า)

ด้วยexists spaceIndexเราสามารถตรวจสอบว่าspaceIndexไม่เป็นโมฆะและทำสิ่งที่แตกต่างจากนั้น (ภายใน if-block คอมไพเลอร์รู้ว่ามันไม่เป็นโมฆะ ... โดยที่มันจะบ่นถ้าฉันใช้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 ซึ่งจะนำเราไปสู่ความคิดที่ว่าเราสามารถส่งผ่านของ tuple ว่าcontainsวิธีการโดยตรง (มันเป็น callable สละวัตถุใด ๆ จึงยังยอมรับตัวอักษร) โดยไม่ต้อง(e) => ...สำเร็จรูป (222 bytes):

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( thenreturn เป็น operand ที่สองเมื่ออันแรกเป็นจริงไม่เช่นนั้น null ซึ่งอนุญาตให้elseส่งคืนตัวถูกดำเนินการตัวที่สองได้) 131 ไบต์ (แม้ว่าการประหยัดบางอย่างเป็น white space ซึ่งเราจะกำจัดออกไป)

String t(String s, Integer l) {
    return s.size < l then s else s[0:(s[0:l-2].lastIndexWhere(" -".contains) else l-3)] + "...";
}

ฟังก์ชั่นที่มีการส่งคืนเพียงครั้งเดียวพร้อมนิพจน์สามารถเขียนด้วยเครื่องหมาย "fat arrow" ได้โดยให้ 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));
    }
}

POSIX เชลล์ + GNU sed, 65 ไบต์

sed -re "s/(.{$1}).+/\1/;T;s/(.*)[- ]...*/\1.../;t;s/...$/.../;:"

นี่คืองานที่ทำเพื่อ sed! แต่ฉันต้องการเชลล์เพื่อให้ได้ขีดจำกัดความยาว (บางที Perl อาจจะดีกว่า) ส่วน sed ขยายออกไปเป็นลำดับที่ค่อนข้างง่ายโดยมีการข้ามแบบมีเงื่อนไขเมื่อเราเสร็จสิ้น:

s/(.{$1}).+/\1/
T
s/(.*)[- ]...*/\1.../
t
s/...$/.../
:

Mathematica 192 ไบต์

t=With[{r=StringTake[#,Min[#2-2,StringLength[#]]],p={"-",Whitespace},e="..."}, 
  Which[StringLength[#]<=#2,#,StringFreeQ[r,p],StringDrop[r,-1]<>e,
   True,StringTake[r,Max[StringPosition[r,p]]-1]<>e]]&

เรียกได้ว่าเป็น

t["This is some very long text.", 25]

> <>, 74 ไบต์

l$-:1)?\~r05.
/?=0:~$<-1
\}:0=  ?\::"- "@=@=+?
>~"..."r\}
/!?     <
>ol?!;

โซลูชันนี้ต้องการให้สตริงถูกตัดทอนและLอยู่ในสแต็กตามลำดับ

มี 7 ไบต์ที่สูญเปล่าที่เกิดจากปัญหาการจัดตำแหน่งยังคงพยายามตีกอล์ฟเหล่านั้นออก

C # (157):

ขึ้นอยู่กับคำตอบของ Salah Alamiแต่สั้นกว่า สตริงบุคลากรระดับจากIEnumerable<char>ดังนั้นแทนที่จะใช้ฉันT.Contains(" ")||T.Contains("-")" -".Any(x=>T.Contains(x))

วิธีการแก้:

string f(string T,int L){if(T.Length<=L)return T;T=T.Substring(0,L-2);return T.Substring(0," -".Any(T.Contains)?T.LastIndexOfAny(new[]{' ','-'}):L-3)+"...";}

Ungolfed:

string f (string T, int L)
{
    if (T.Length <= L)
        return T;

    T = T.Substring(0, L - 2);

    return T.Substring(0, " -".Any(T.Contains) ? T.LastIndexOfAny(new[]{' ', '-'}) : L - 3) + "...";
}

ปรับปรุง:

ที่บันทึกไว้ 6 ไบต์ขอบคุณที่ความคิดเห็นของ SLuck49 ที่ใช้แทนAny(T.Contains)Any(x=>T.Contains(x))

GS2 , 29 ไบต์

โปรแกรมนี้ใช้อินพุตมาตรฐาน บรรทัดแรกคือสตริงและที่สองคือหมายเลขความยาวเป้าหมาย

2a 0e 56 3c 40 a0 74 20 22 22 04 5d 2e 2a 3f 5b
20 2d 5d 7c 2e 07 2e 2e 2e 9d 20 e4 35

บางครั้งรหัส GS2 อาจอ่านยากสักหน่อย :) นี่เป็นคำอธิบาย

2a         # lines - split input on newlines yielding a two element array
0e         # extract-array - pop array, push both elements 
56         # read-num - convert length string to number
3c         # take - truncate the string to specified length
40         # dup - duplicate truncated string on stack
a0         # junk1 - push the last popped value, the un-truncated string
74         # ne - test for inequality
    20     # reverse string
    22 22  # tail tail - remove first two characters

    # regex replace first occurrence of ".*?[ -]|." with "..."
    04 5d 2e 2a 3f 5b 20 2d 5d 7c 2e 07 2e 2e 2e 9d 

    20     # reverse string
e4         # block5 - make a block out of last 5 instructions
35         # when - conditionally execute block

Groovy ขนาด 56 ไบต์

คัดลอกคำตอบของ Kleyguerth ก่อนดังนั้นชื่อตัวแปรเดียวกัน ...

ตัดแต่งสตริงลง 2 ตัวอักษรจากนั้นงานส่วนใหญ่จะกระทำโดย regex แทนที่เส้นประหรือช่องว่างตามด้วยตัวอักษรจำนวนใด ๆ ที่ไม่ใช่เส้นประหรือช่องว่างที่ส่วนท้ายของสตริงด้วย "" หรือแทนที่ตัวอักษรใด ๆ ที่ส่วนท้ายของสตริงถ้าตัวอักษรทั้งหมดก่อนที่จะไม่มีเส้นประหรือเว้นวรรคด้วย "." ยากที่จะใส่คำพูดมากกว่าเขียน regex ...

a={T,L->T.size()<=L?T:T[0..L-3].replaceAll("([- ][^ -]*|(?<=[^- ]*).)\$",".")+".."}

แก้ไข: ที่จริงแล้วสามารถลบส่วนของสตริงที่ตรงกับ regex และเพิ่ม "... " ในตอนท้าย:

a={T,L->T.size()<=L?T:T[0..L-3]-~/[- ][^ -]*$|.$/+"..."}

เยลลี่ 29 ไบต์

ḣṖṖe€⁾ -œṗƊṖȯ$Ẏḣ⁹_3¤”.⁺⁺ðL>¥¡

ลองออนไลน์!

โปรแกรมเต็มรูปแบบ

ทำความสะอาด , 89 ไบต์

import StdEnv
$n l|size l>n=l%(0,last[n:[i\\i<-[2..n]&c<-:l|c==' '||c=='-']]-3)+++"..."=l

ลองออนไลน์!

เป็นฟังก์ชั่น $ :: Int String -> String

C # (Visual C # Interactive Compiler) , 117 ไบต์

a=>b=>a.Length>b?a.Substring(0,(" -".Any(x=>a.IndexOf(x,0,b-2)>-1)?a.LastIndexOfAny(new[]{' ','-'},b-2):b-3))+"...":a

อ้างอิงจาก @ Abba's ซึ่งอิงจากคำตอบของ @Salah Alami แทนที่จะใช้ContainsและการSubstringโทรที่ไม่จำเป็นจะใช้ IndexOf เพื่อตรวจสอบว่ามียัติภังค์หรือพื้นที่ว่างในสตริงที่ถูกตัดทอน

ลองออนไลน์!