คุณไม่ชอบไดอะแกรมมุมมองที่ระเบิดซึ่งเครื่องจักรหรือวัตถุถูกแยกออกเป็นชิ้นเล็ก ๆ หรือไม่?

ลองทำกับสตริง!

ความท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่

1. ปัจจัยการผลิตสตริงที่มีเพียงตัวอักขระ ASCII ;
2. แยกสตริงออกเป็นกลุ่มของอักขระที่ไม่เท่ากับช่องว่าง ("ส่วน" ของสตริง)
3. ผลกลุ่มผู้ที่อยู่ในรูปแบบที่สะดวกใด ๆ กับบางคั่นระหว่างกลุ่ม

ตัวอย่างเช่นกำหนดสตริง

Ah, abracadabra!

ผลลัพธ์จะเป็นกลุ่มต่อไปนี้:

!
,

aaaaa
BB
ค
d
ชั่วโมง
RR

แต่ละกลุ่มในเอาต์พุตมีอักขระที่เท่ากันโดยลบช่องว่างออก มีการใช้การขึ้นบรรทัดใหม่เป็นตัวคั่นระหว่างกลุ่ม เพิ่มเติมเกี่ยวกับรูปแบบที่อนุญาตด้านล่าง

กฎระเบียบ

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

คุณสามารถสรุปได้ว่าการป้อนข้อมูลที่มีอย่างน้อยหนึ่งตัวละครที่ไม่ใช่พื้นที่

ส่งออกควรประกอบด้วยตัวอักษร (แม้ว่าใส่เป็นโดยความหมายของรหัส ASCII) จะต้องมีตัวคั่นที่ชัดเจนระหว่างกลุ่มซึ่งแตกต่างจากอักขระที่ไม่ใช่ช่องว่างที่อาจปรากฏในอินพุต

ถ้าเอาต์พุตส่งคืนโดยฟังก์ชันส่งคืนอาจเป็นอาร์เรย์หรือสตริงหรืออาร์เรย์ของ chars หรือโครงสร้างที่คล้ายกัน ในกรณีนั้นโครงสร้างให้แยกที่จำเป็น

ตัวคั่นระหว่างตัวละครของแต่ละกลุ่มเป็นตัวเลือก หากมีข้อใดข้อหนึ่งกฎเดียวกันจะมีผลบังคับใช้: จะต้องไม่ใช่อักขระที่ไม่ใช่ช่องว่างที่อาจปรากฏในอินพุต นอกจากนี้มันไม่สามารถเป็นตัวคั่นเดียวกับที่ใช้ระหว่างกลุ่ม

นอกจากนั้นรูปแบบยังยืดหยุ่น นี่คือตัวอย่างบางส่วน:

• กลุ่มอาจเป็นสตริงที่คั่นด้วยการขึ้นบรรทัดใหม่ดังแสดงด้านบน

• กลุ่มอาจจะแยกออกจากตัวอักษรใด ๆ ที่ไม่ใช่ ASCII ¬เช่น เอาต์พุตสำหรับอินพุตด้านบนจะเป็นสตริง:

  !¬,¬A¬aaaaa¬bb¬c¬d¬h¬rr
  

• กลุ่มอาจถูกคั่นด้วยn > 1 ช่องว่าง (แม้ว่าnคือตัวแปร) โดยมีตัวอักษรระหว่างแต่ละกลุ่มคั่นด้วยช่องว่างเดียว:

  !  ,    A   a a a a a    b b  c       d   h  r r
  

• ผลลัพธ์อาจเป็นอาร์เรย์หรือรายการสตริงที่ส่งคืนโดยฟังก์ชัน

  ['!', 'A', 'aaaaa', 'bb', 'c', 'd', 'h', 'rr']
  

• หรืออาร์เรย์อาร์เรย์ถ่าน:

  [['!'], ['A'], ['a', 'a', 'a', 'a', 'a'], ['b', 'b'], ['c'], ['d'], ['h'], ['r', 'r']]
  

ตัวอย่างของรูปแบบที่ไม่อนุญาตตามกฎ:

• ไม่สามารถใช้เครื่องหมายจุลภาคเป็นตัวคั่น ( !,,,A,a,a,a,a,a,b,b,c,d,h,r,r) เนื่องจากอินพุตอาจมีเครื่องหมายจุลภาค
• ไม่อนุญาตให้วางตัวคั่นระหว่างกลุ่ม ( !,Aaaaaabbcdhrr) หรือใช้ตัวคั่นเดียวกันระหว่างกลุ่มและภายในกลุ่ม ( ! , A a a a a a b b c d h r r)

กลุ่มอาจปรากฏขึ้นตามลำดับใด ๆในผลลัพธ์ ตัวอย่างเช่น: ลำดับตัวอักษร (ตามตัวอย่างด้านบน) ลำดับของการปรากฏตัวครั้งแรกในสตริง, ... ลำดับไม่จำเป็นต้องสอดคล้องกันหรือแม้แต่กำหนด

โปรดทราบว่าอินพุตไม่สามารถมีอักขระขึ้นบรรทัดใหม่และAและaเป็นอักขระอื่น (การจัดกลุ่มเป็นแบบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ )

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

ในแต่ละกรณีทดสอบบรรทัดแรกคืออินพุตและบรรทัดที่เหลือคือเอาต์พุตโดยแต่ละกลุ่มในบรรทัดที่แตกต่างกัน

• กรณีทดสอบ 1:

  อ่า abracadabra!
  !
  ,
  
  aaaaa
  BB
  ค
  d
  ชั่วโมง
  RR
  

• กรณีทดสอบ 2:

  \ o / \ o / \ o /
  ///
  \\\
  OOO
  

• กรณีทดสอบ 3:

  ผู้ชายแผนคลอง: ปานามา!
  !
  ,,
  :
  
  P
  aaaaaaaaa
  ค
  LL
  มิลลิเมตร
  NNNN
  พี
  

• กรณีทดสอบ 4:

  "แสดงให้ฉันดูว่าคุณทำยังไงกับกลอุบายที่ทำให้ฉันกรี๊ด" เธอพูด
  ""
  ,
  S
  aaaaa
  ซีซี
  DD
  eeeeeee
  hhhhhh
  ii
  kk
  mmmm
  n
  ooooo
  RR
  ssss
  tttttt
  ยู
  WW
  Y
  

เยลลี่ 5 ไบต์

ḟ⁶ṢŒg

ลองออนไลน์!

มันจะส่งกลับอาร์เรย์เพียงว่าเมื่อมันถูกพิมพ์ไปยัง STDOUT ตัวแยกจะหายไป

นี่คือฟังก์ชั่นที่สามารถเรียกได้ว่าเป็นเช่นนี้ (ใน Jelly, แต่ละบรรทัดคือฟังก์ชัน)

ḟ⁶ṢŒg
ḟ⁶      filter out spaces
  Ṣ     sort
   Œg   group

Python 3.5+, 77 46 44 41 ไบต์

lambda s:[a*s.count(a)for a in{*s}-{' '}]

ค่อนข้างง่าย จะต้องผ่านตัวละครที่ไม่ซ้ำกันในสตริงโดยแปลงเป็นชุด (โดยใช้ Python 3.5 ขยาย iterable เอาออก) str.countจากนั้นใช้ความเข้าใจในรายชื่อที่จะสร้างระเบิดแผนภาพโดยการนับจำนวนครั้งที่ตัวละครแต่ละตัวที่เกิดขึ้นในสตริงกับ เรากรองช่องว่างโดยลบออกจากชุด

ลำดับของผลลัพธ์อาจแตกต่างกันไป เซตไม่เรียงลำดับดังนั้นลำดับที่ประมวลผลรายการและดังนั้นจึงไม่สามารถรับประกันคำตอบนี้ได้

นี่คือการแสดงออกแลมบ์ดา; ที่จะใช้คำนำหน้าด้วยlambdaf=

ลองใช้กับ Ideone! Ideone ใช้ Python 3.4 ซึ่งไม่เพียงพอ

ตัวอย่างการใช้งาน:

>>> f=lambda s:[a*s.count(a)for a in{*s}-{' '}]
>>> f('Ah, abracadabra!')
[',', 'A', 'aaaaa', 'd', '!', 'bb', 'h', 'c', 'rr']

บันทึก 3 ไบต์ขอบคุณ @shooqie!

เรติน่า 13 ไบต์

O`.
!`(\S)\1*

การเรียงลำดับนั้นง่ายมาก (เป็นแบบบิลท์อิน) โดยแยกตัวอักษรที่มีขนาด 9 ไบต์ ลองออนไลน์!

สายแรก s Orts การแข่งขันทั้งหมดของ regex ไม่.(ซึ่งเป็นตัวละครทุกตัว) !,Aaaaaabbcdhrrให้เรา

การจับคู่เป็นระยะเริ่มต้นสำหรับบรรทัดสุดท้ายของโปรแกรมและ !ทำให้มันพิมพ์รายการการจับคู่ linefeed ที่คั่นด้วยบรรทัดของ regex regex จะค้นหาอินสแตนซ์ของอักขระที่ไม่ใช่ช่องว่างอย่างน้อยหนึ่งรายการในแถว

Perl 6 , 28 ไบต์

*.comb(/\S/).Bag.kv.map(*x*)

ทราบว่ากระเป๋าเหมือนแฮหรือSetนั้นไม่มีการเรียงลำดับดังนั้นจึงไม่รับประกันลำดับของผลลัพธ์

คำอธิบาย:

# Whatever lambda ｢*｣


# grab the characters
*.comb(
  # that aren't white-space characters
  /\S/
)
# ("A","h",",","a","b","r","a","c","a","d","a","b","r","a","!")


# Turn into a Bag ( weighted Set )
.Bag
# {"!"=>1,","=>1,"A"=>1,"a"=>5,"b"=>2,"c"=>1,"d"=>1,"h"=>1,"r"=>2}


# turn into a list of characters and counts
.kv
# ("!",1,",",1,"A",1,"a",5,"b",2,"c",1,"d",1,"h",1,"r",2)


# map over them 2 at a time
.map(
  # string repeat the character by the count
  * x *
)
# ("!",",","A","aaaaa","bb","c","d","h","rr")

เป็นกลุ่ม50 , 46 ไบต์

i <esc>:s/./&\r/g
:sor
qq:%s/\v(.)\n\1/\1\1
@qq@qD

คำอธิบาย / gif จะมาในภายหลัง

Pyth, 6

.gk-zd

ลองที่นี่หรือเรียกใช้ชุดทดสอบ

ค่อนข้างง่าย-zdลบช่องว่างจากอินพุตและ.gkจัดกลุ่มองค์ประกอบที่เหลือแต่ละรายการตามค่าของมัน น่าเสียดายที่ฉันไม่พบวิธีใช้ประโยชน์จากตัวแปรเติมอัตโนมัติ โปรดทราบว่าเอาต์พุตจะแสดงเป็นสตริง Python ดังนั้นอักขระบางตัว (read: backslashes) จึงถูกยกเว้น หากคุณต้องการให้อ่านง่ายขึ้นให้เพิ่ม a jไว้ที่จุดเริ่มต้นของโค้ด

Haskell, 38 ไบต์

f s=[filter(==c)s|c<-['!'..],elem c s]

วิธีการแก้ปัญหาโดยทั่วไปของ nimiแต่ตรวจสอบเฉพาะตัวอักษรที่ปรากฏในสตริง

2sable , 7 ไบต์

รหัส:

Úð-vyÃ,

คำอธิบาย:

Ú       # Uniquify the string, aabbcc would result into abc
 ð-     # Remove spaces
   vy   # For each character...
     Ã  #   Keep those in the string, e.g. 'aabbcc', 'a' would result into 'aa'
      , #   Pop and print with a newline

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!

JavaScript (ES6), 41 ไบต์

s=>[...s].sort().join``.match(/(\S)\1*/g)

Brachylogขนาด14 7 ไบต์

7 ไบต์ต้องขอบคุณ Fatalize

:@Sxo@b

ลองออนไลน์!

:@Sxo@b
:@Sx     remove spaces
    o    sort
     @b  group

Haskell, 40 ไบต์

f x=[v:w|d<-['!'..],v:w<-[filter(==d)x]]

ตัวอย่างการใช้งาน: ->f "Ah, abracadabra!"["!",",","A","aaaaa","bb","c","d","h","rr"]

รูปแบบv:wจับคู่รายการที่มีองค์ประกอบอย่างน้อยหนึ่งรายการเท่านั้นดังนั้นอักขระทั้งหมดที่ไม่ได้อยู่ในอินพุตจะถูกละเว้น

นอกจากนี้ 40 ไบต์:

import Data.List
group.sort.filter(>' ')

Ruby, 41 + 1 = 42 ไบต์

+1 ไบต์สำหรับการ-nตั้งค่าสถานะ

gsub(/(\S)(?!.*\1)/){puts$1*$_.count($1)}

รับอินพุตบน stdin เช่น:

$ echo 'Ah, abracadabra!' | ruby -ne 'gsub(/(\S)(?!.*\1)/){puts$1*$_.count($1)}'
A
h
,
c
d
bb
rr
aaaaa
!

C # 125 98 ไบต์

using System.Linq;s=>s.GroupBy(c=>c).Where(g=>g.Key!=' ').Select(g=>new string(g.Key,g.Count())));

คำอธิบาย

//Using anonymous function to remove the need for a full signature 
//And also allow the implicit return of an IEnumerable
s =>

    //Create the groupings
    s.GroupBy(c => c)

    //Remove spaces
    .Where(g=> g.Key!=' ')

    //Generate a new string using the grouping key (the character) and repeating it the correct number of times
    .Select(g => new string(g.Key, g.Count()));

• ขอบคุณ @TheLethalCoder ที่แนะนำให้ใช้ฟังก์ชั่นที่ไม่ระบุชื่อซึ่งทำให้ฉันสามารถลบการToArrayโทรออกและเพียงแค่คืนค่า IEnumerable ที่รวม 27 ไบต์ไว้ด้วยกัน

R, 198 189 96 95 ไบต์

for(i in unique(a<-strsplit(gsub(" ","",readline()),"")[[1]]))cat(rep(i,sum(a==i)),"\n",sep="")

Ungolfed:

a<-strsplit(gsub(" ","",readline()),"")[[1]] #Takes the input from the console

for(i in unique(a)) #loop over unique characters found in variable a

cat(rep(i,sum(a==i)),"\n",sep="") # print that character n times, where n was the number of times it appeared

วิธีการแก้ปัญหานี้ไม่สามารถใช้งานได้เมื่อ\มีส่วนร่วม
ตอนนี้มันเป็น!

ขอบคุณมากที่ @JDL สำหรับการเล่นกอล์ฟขนาด102ไบต์!

สวิฟต์, 105 91 ไบต์

ขอบคุณ @NobodyNada สำหรับ 14 ไบต์ :)

ใช่ฉันค่อนข้างใหม่กับสวิฟท์ ...

func f(a:[Character]){for c in Set(a){for d in a{if c==d && c != " "{print(c)}}
print("")}}

อักขระภายในกลุ่มจะถูกคั่นด้วยบรรทัดใหม่หนึ่งบรรทัด กลุ่มจะถูกคั่นด้วยบรรทัดใหม่สองบรรทัด

อ็อกเทฟ 61 ไบต์

@(x)mat2cell(y=strtrim(sort(x)),1,diff(find([1 diff(+y) 1])))

นี่คือฟังก์ชัน anoymous ที่รับสตริงเป็นอินพุตและเอาต์พุตเซลล์อาร์เรย์ของสตริง

ลองที่ Ideone

มันทำงานอย่างไร

• sortเรียงลำดับสตริงอินพุต โดยเฉพาะช่องว่างจะอยู่ที่จุดเริ่มต้น
• strtrim ลบช่องว่างนำหน้า
• diff(+y) คำนวณความแตกต่างอย่างต่อเนื่องระหว่างตัวละคร (เพื่อตรวจจับขอบเขตกลุ่ม) ...
• ... เพื่อdiff(find([1 diff(+y) 1])ให้เวกเตอร์มีขนาดกลุ่ม
• mat2cell จากนั้นแยกสตริงที่เรียงลำดับเป็นชิ้นที่มีขนาดดังกล่าว

Mathematica ขนาด 36 ไบต์

ฟังก์ชันในตัวGatherและทำงานCharactersส่วนใหญ่ได้ที่นี่

Gather@Select[Characters@#,#!=" "&]&

> <> , 49 ไบต์

i:0(?v
84}0~/&{!*
v!?: <}/?=&:&:<
>&1+&}aol1-?!;^

สิ้นเปลืองกว้างขวางมากในผลลัพธ์ แต่ฉันถือว่ายังอนุญาตให้ใช้ความอ่อนโยนของกฎ

คำอธิบาย:

i:0(?v           Collects text from input
84}0~/&{!*       adds 32 (first ascii starting at space) to register and 0 to stack
v!?: <}/?=&:&:<  checks all characters to the current register, if equal:
       o         prints the character and continues looping
>&1+&}aol1-?!;^  when all characters are checked, adds 1 to register, prints a newline,
                 checks the stack length to halt the program if 0, and starts looping again

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

โดยพื้นฐานแล้วสิ่งนี้จะทำให้อักขระ ASCII แต่ละตัวขึ้นบรรทัดใหม่ของตัวเองและหากไม่มีตัวอักษรนั้นอยู่บรรทัดนั้นจะว่างเปล่า

ลองออนไลน์

แก้ไข: ฉันผิดมีข้อผิดพลาดในรหัสสิ่งที่จะทำให้มันไม่สมบูรณ์ถ้ามีช่องว่างในการป้อนข้อมูล

Pyth, 5 ไบต์

.gksc

ลองที่นี่!

รับอินพุตเป็นสตริง Python (เช่นถูกห่อในเครื่องหมายคำพูด, อัญประกาศและเครื่องหมายทับตามความจำเป็น)

คำอธิบาย:

    c    Split (implied) input on whitespace
   s     Sum together
.gk      Group by value

หากคุณรับประกันว่ามีช่องว่างอย่างน้อยหนึ่งช่องในอินพุตมีวิธี 4 ไบต์:

t.gk

ลองที่นี่!

คำอธิบาย:

 .gk (Q)  groups the characters in the string by their value
           this sorts them by their value, which guarantees that spaces are first
t         Remove the first element (the spaces)

PowerShell v2 +, 44 ไบต์

[char[]]$args[0]-ne32|group|%{-join$_.Group}

รับอินพุต$args[0]เป็นสตริงตัวอักษรของอาร์กิวเมนต์บรรทัดคำสั่ง ปลดเปลื้องที่เป็นchar-array และใช้ตัวดำเนินการ-not equal เพื่อดึงช่องว่าง (ASCII32 ) วิธีนี้ใช้งานได้เนื่องจากการหล่อมีลำดับความสำคัญสูงกว่าและเมื่อใช้อาร์เรย์เป็นตัวดำเนินการมือซ้ายที่มีสเกลาร์เป็นมือขวาจะทำหน้าที่เหมือนตัวกรอง

เราส่งต่ออาร์เรย์ของตัวละครไปยังGroup-Objectซึ่งทำสิ่งที่มันบอกว่า โปรดทราบว่าเนื่องจากเรากำลังส่งผ่านตัวละครไม่ใช่สตริงกลุ่มนี้จะต้องมีตัวพิมพ์เล็กและตัวพิมพ์ใหญ่

ตอนนี้เรามีออบเจกต์ที่กำหนดเองที่มีชื่อกลุ่มจำนวนนับ ฯลฯ หากเราพิมพ์ออกมาเราจะมีโฮสต์ของเอาต์พุตภายนอก ดังนั้นเราจำเป็นต้องท่อที่เป็นห่วง|%{...}และแต่ละซ้ำ-join.Groupเข้าด้วยกันเป็นสายเดียว สตริงผลลัพธ์เหล่านั้นจะถูกทิ้งไว้บนไพพ์ไลน์และเอาต์พุตจะเป็นนัยเมื่อโปรแกรมเสร็จสิ้น

ตัวอย่าง

PS C:\Tools\Scripts\golfing> .\exploded-view-of-substrings.ps1 'Programming Puzzles and Code Golf'
PP
rr
ooo
gg
aa
mm
i
nn
u
zz
ll
ee
s
dd
C
G
f

Dyalog APL , 11ขนาดไบต์

ฟังก์ชันส่งคืนรายการสตริง

(⊂∩¨∪)~∘' '

(⊂∩¨∪) จุดตัดของทั้งตัวและอักขระที่เป็นเอกลักษณ์

~∘' ' ยกเว้นช่องว่าง

ลองใช้ออนไลน์!

กำลังประมวลผล 109 ไบต์

void s(char[] x){x=sort(x);char l=0;for(char c:x){if(c!=l)println();if(c!=' '&&c!='\n'&&c!='\t')print(c);l=c;}}

มันเข้าใกล้แรงเดรัจฉานเรียงแถวแล้ววนผ่านมัน หากไม่ตรงกับอักขระตัวสุดท้ายที่พิมพ์ให้พิมพ์บรรทัดใหม่ก่อน หากเป็นช่องว่างข้ามขั้นตอนการพิมพ์

Javascript (ใช้ไลบรารีภายนอก - นับได้) ( 78 67 ไบต์)

 n=>_.From(n).Where(y=>y!=' ').GroupBy(x=>x).WriteLine(y=>y.Write())

ลิงก์ไปยัง lib: https://github.com/mvegh1/Enumerable

คำอธิบายโค้ด: นี่คือสิ่งที่ทำให้นับได้ทำ! โหลดสตริงลงในไลบรารีซึ่งแปลงเป็นอาเรย์ถ่าน กรองรายการ white space จัดกลุ่มโดย char. เขียนแต่ละกลุ่มไปยังบรรทัดตามภาคแสดงที่ระบุ เพรดิเคตนั้นบอกว่าจะเข้าร่วมองค์ประกอบทั้งหมดของกลุ่มปัจจุบันลงในสตริงโดยไม่ต้องมีตัวคั่น

MATL, 7 ไบต์

Xz!t7XQ

การสาธิต MATL ออนไลน์

Perl6, 48 47 45

slurp.comb.Bag.kv.map:{$^a.trim&&say $a x$^b}

ขอบคุณ manatwork สำหรับการปรับปรุง

Ruby, 46 ไบต์

ลองออนไลน์!

->s{(s.chars-[' ']).uniq.map{|c|c*s.count(c)}}

เวอร์ชันเต็มโปรแกรมต้นฉบับของฉัน 48 ไบต์หลังจากเพิ่มการnตั้งค่าสถานะ:

p gsub(/\s/){}.chars.uniq.map{|c|c*$_.count(c)}

Python, 107

อาจถูกทำให้สั้นลงด้วยแลมบ์ดา แต่ต่อมา

x=sorted(input())
i=0
while i<len(x):x[i:]=['  '*(x[i]!=x[i-1])]+x[i:];i-=~(x[i]!=x[i-1])
print("".join(x))

CJam, 10 ไบต์

{S-$e`::*}

บล็อกที่ไม่มีชื่อที่คาดว่าสตริงจะอยู่ด้านบนสุดของสแต็กและแทนที่ด้วยรายการของสตริง

ลองออนไลน์!

คำอธิบาย

S-  Remove spaces.
$   Sort.
e`  Run-length encode, gives pairs [R C], where R is the run-length and
    C is the character.
::* Repeat the C in each pair R times.

เสียงกระเพื่อมสามัญ 123

(lambda(s &aux(w(string-trim" "(sort s'char<))))(princ(elt w 0))(reduce(lambda(x y)(unless(char= x y)(terpri))(princ y))w))

Ungolfed:

(lambda (s &aux (w (string-trim " " (sort s 'char<))))
  (princ (elt w 0))
  (reduce
    (lambda (x y) 
      (unless (char= x y) (terpri))
      (princ y))
  w))

ไม่ใช่ภาษาที่เป็นมิตรกับกอล์ฟมากที่สุด สิ่งนี้อาจถูกปรับเปลี่ยนเพื่อส่งคืนรายการรายการแทนที่จะพิมพ์สตริง

Emacs การกดแป้น 36 ครั้ง

C-SPACE C-EM-xsort-rTABRETURN.RETURN.RETURNC-AC-M-S-%\(\(.\)\2*\)RETURN\1C-QC-JRETURN!

ผลลัพธ์

A man, a plan, a canal: Panama! ->

!
,,
:
A
P
aaaaaaaaa
c
ll
mm
nnnn
p

คำอธิบาย

1. C-SPACE C-E
2. M-x sort-rTAB RETURN .RETURN .RETURN
3. C-A
4. C-M-S-% \(\(.\)\2*\)RETURN\1 C-Q C-JRETURN !

1. เลือกบรรทัดอินพุต
2. โทรsort-regexp-fieldsด้วยข้อโต้แย้ง.และ.;
   • อาร์กิวเมนต์ # 1: Regexp scpecifying บันทึกเพื่อเรียงลำดับ
   • อาร์กิวเมนต์ # 2: Regexp การระบุคีย์ภายในระเบียน
3. กลับมาที่จุดเริ่มต้นบรรทัด;
4. ใช้การทดแทน regexp \(\(.\)\2*\)-> \1\nในการแข่งขันทั้งหมด