Bạn không thích những sơ đồ xem nổ tung trong đó một máy hoặc vật thể được tách ra thành những mảnh nhỏ nhất của nó?

Hãy làm điều đó với một chuỗi!

Các thách thức

Viết chương trình hoặc chức năng

1. nhập một chuỗi chỉ chứa các ký tự ASCII có thể in được ;
2. phân chia chuỗi thành các nhóm ký tự không phải không gian bằng nhau ("phần" của chuỗi);
3. xuất các nhóm đó ở bất kỳ định dạng thuận tiện nào, với một số dấu phân cách giữa các nhóm .

Ví dụ, đưa ra chuỗi

Ah, abracadabra!

đầu ra sẽ là các nhóm sau:

!
,
Một
aaaaa
bb
c
d
h
rr

Mỗi nhóm trong đầu ra chứa các ký tự bằng nhau, với khoảng trắng được loại bỏ. Một dòng mới đã được sử dụng như là dấu phân cách giữa các nhóm. Thêm về các định dạng được phép dưới đây.

Quy tắc

Đầu vào phải là một chuỗi hoặc một mảng ký tự. Nó sẽ chỉ chứa các ký tự ASCII có thể in được (phạm vi bao gồm từ không gian đến dấu ngã). Nếu ngôn ngữ của bạn không hỗ trợ điều đó, bạn có thể lấy đầu vào dưới dạng số đại diện cho mã ASCII.

Bạn có thể giả sử rằng đầu vào chứa ít nhất một ký tự không phải không gian .

Đầu ra phải bao gồm các ký tự (ngay cả khi đầu vào là bằng mã ASCII). Phải có một dấu tách rõ ràng giữa các nhóm , khác với bất kỳ ký tự không phải không gian nào có thể xuất hiện trong đầu vào.

Nếu đầu ra là thông qua trả về hàm, nó cũng có thể là một mảng hoặc chuỗi hoặc một mảng các mảng ký tự hoặc cấu trúc tương tự. Trong trường hợp đó, cấu trúc cung cấp sự tách biệt cần thiết.

Một dấu phân cách giữa các ký tự của mỗi nhóm là tùy chọn . Nếu có một, quy tắc tương tự được áp dụng: đó không thể là một ký tự không phải không gian có thể xuất hiện trong đầu vào. Ngoài ra, nó không thể là dấu phân cách giống như được sử dụng giữa các nhóm.

Ngoài ra, định dạng là linh hoạt. Dưới đây là một số ví dụ:

• Các nhóm có thể được phân tách bằng các dòng mới, như được hiển thị ở trên.

• Các nhóm có thể được phân tách bằng bất kỳ ký tự không phải ASCII nào, chẳng hạn như ¬. Đầu ra cho đầu vào trên sẽ là chuỗi:

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

• Các nhóm có thể được phân tách bằng n > 1 khoảng trắng (ngay cả khi n là biến), với các ký tự giữa mỗi nhóm được phân tách bằng một khoảng trắng :

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

• Đầu ra cũng có thể là một mảng hoặc danh sách các chuỗi được trả về bởi một hàm:

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

• Hoặc một mảng các mảng char:

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

Ví dụ về các định dạng không được phép, theo các quy tắc:

• Dấu phẩy không thể được sử dụng làm dấu phân cách ( !,,,A,a,a,a,a,a,b,b,c,d,h,r,r), vì đầu vào có thể chứa dấu phẩy.
• Không được chấp nhận thả dải phân cách giữa các nhóm ( !,Aaaaaabbcdhrr) hoặc sử dụng cùng một dấu phân cách giữa các nhóm và trong các nhóm ( ! , A a a a a a b b c d h r r).

Các nhóm có thể xuất hiện theo thứ tự bất kỳ trong đầu ra. Ví dụ: thứ tự chữ cái (như trong các ví dụ ở trên), thứ tự xuất hiện đầu tiên trong chuỗi, ... Thứ tự không cần phải nhất quán hoặc thậm chí là xác định.

Lưu ý rằng đầu vào không thể chứa các ký tự dòng mới Avà alà các ký tự khác nhau (nhóm được phân biệt chữ hoa chữ thường ).

Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

Trong mỗi trường hợp thử nghiệm, dòng đầu tiên là đầu vào và các dòng còn lại là đầu ra, với mỗi nhóm trong một dòng khác nhau.

• Trường hợp thử nghiệm 1:

  A, abracadabra!
  !
  ,
  Một
  aaaaa
  bb
  c
  d
  h
  rr
  

• Trường hợp thử nghiệm 2:

  \ o / \ o / \ o /
  ///
  \
  ooo
  

• Trường hợp thử nghiệm 3:

  Một người đàn ông, một kế hoạch, một con kênh: Panama!
  !
  ,,
  :
  Một
  P
  aaaaaaaaa
  c
  sẽ
  mm
  không
  p
  

• Trường hợp thử nghiệm 4:

  "Chỉ cho tôi cách bạn thực hiện mánh khóe đó, người khiến tôi hét lên", cô nói
  ""
  ,
  S
  aaaaa
  cc
  đ
  eeeeeee
  hhhhhh
  ii
  kk
  Ừm
  n
  ooooo
  rr
  sss
  tttttt
  bạn
  tuần
  y
  

Thạch , 5 byte

ḟ⁶ṢŒg

Hãy thử trực tuyến!

Nó trả về một mảng, chỉ khi nó được in ra STDOUT, dấu phân cách sẽ biến mất.

Đây thực sự là một hàm có thể được gọi như vậy (trong Jelly, mỗi dòng là một hàm).

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

Python 3.5+, 77 46 44 41 byte

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

Khá đơn giản. Đi qua các ký tự duy nhất trong chuỗi bằng cách chuyển đổi nó thành một tập hợp (sử dụng giải nén lặp lại mở rộng của Python 3.5), sau đó sử dụng cách hiểu danh sách để xây dựng các sơ đồ đã nổ bằng cách đếm số lần mỗi ký tự xuất hiện trong chuỗi str.count. Chúng tôi lọc không gian bằng cách loại bỏ chúng khỏi bộ.

Thứ tự của đầu ra có thể thay đổi từ chạy sang chạy; các tập hợp không có thứ tự, vì vậy thứ tự các mục của chúng được xử lý, và do đó câu trả lời này xuất ra, không thể được đảm bảo.

Đây là một biểu thức lambda; để sử dụng nó, tiền tố lambdavới f=.

Hãy thử nó trên Ideone! Ideone sử dụng Python 3.4, không đủ.

Ví dụ sử dụng:

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

Đã lưu 3 byte nhờ @shooqie!

Võng mạc, 13 byte

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

Việc sắp xếp rất dễ dàng (nó là một nội dung), nó phân tách các chữ cái mất 9 byte. Hãy thử trực tuyến!

Dòng đầu tiên Orts tất cả các trận đấu của regex .(là mọi nhân vật), mang lại cho chúng ta !,Aaaaaabbcdhrr.

Trận đấu là giai đoạn mặc định cho dòng cuối cùng của chương trình và !làm cho nó in một danh sách các trận đấu được phân tách bằng nguồn cấp dữ liệu của biểu thức chính quy. Regex tìm kiếm một hoặc nhiều phiên bản của một ký tự không phải khoảng trắng trong một hàng.

Perl 6 , 28 byte

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

Lưu ý rằng Túi như Hash hoặc Set không có thứ tự nên thứ tự kết quả không được đảm bảo.

Giải trình:

# 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")

Vim, 50 , 46 byte

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

Giải thích / gif sẽ đến sau.

Bình thường, 6

.gk-zd

Dùng thử tại đây hoặc chạy Test Suite .

Khá đơn giản, -zdloại bỏ khoảng trắng khỏi đầu vào và .gknhóm từng phần tử còn lại theo giá trị của nó. Thật không may, tôi không tìm thấy cách sử dụng các biến tự động điền. Lưu ý rằng đầu ra được hiển thị dưới dạng chuỗi Python, vì vậy các ký tự nhất định (đọc: dấu gạch chéo ngược) được thoát. Nếu bạn muốn nó dễ đọc hơn, hãy thêm a jvào đầu mã.

Haskell, 38 byte

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

Về cơ bản giải pháp của nimi , nhưng chỉ kiểm tra rõ ràng các chữ cái xuất hiện trong chuỗi.

2sable , 7 byte

Mã số:

Úð-vyÃ,

Giải trình:

Ú       # 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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

JavaScript (ES6), 41 byte

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

Brachylog , 14 7 byte

7 byte nhờ Fatalize.

:@Sxo@b

Hãy thử trực tuyến!

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

Haskell, 40 byte

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

Ví dụ sử dụng: f "Ah, abracadabra!"-> ["!",",","A","aaaaa","bb","c","d","h","rr"].

Mẫu v:wchỉ khớp với danh sách có ít nhất một thành phần, vì vậy tất cả các ký tự không có trong đầu vào đều bị bỏ qua.

Ngoài ra 40 byte:

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

Ruby, 41 + 1 = 42 byte

+1 byte cho -ncờ.

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

Đưa đầu vào vào stdin, vd:

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

C # 125 98 byte

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

Giải trình

//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()));

• Cảm ơn @TheLethalCoder, người đã đề xuất sử dụng chức năng ẩn danh, điều này cũng cho phép tôi xóa ToArraycuộc gọi và hoàn toàn trả lại một IEnumerable để lưu chung 27 byte

R, 198 189 96 95 byte

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

Ung dung:

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

Giải pháp này hiện không hoàn toàn hoạt động, khi \có liên quan.
Bây giờ thì đúng là vậy !

Cảm ơn bạn rất nhiều @JDL vì đã chơi hết 102 byte!

Swift, 105 91 byte

Cảm ơn @NobodyNada cho 14 byte :)

Vâng, tôi khá mới với Swift ...

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

Các nhân vật trong một nhóm được phân tách bằng một dòng mới. Các nhóm được phân cách bởi hai dòng mới.

Octave , 61 byte

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

Đây là một hàm anoymous lấy một chuỗi làm đầu vào và xuất ra một chuỗi ô của chuỗi.

Hãy thử tại Ideone .

Làm thế nào nó hoạt động

• sortsắp xếp chuỗi đầu vào. Đặc biệt, không gian sẽ ở đầu.
• strtrim loại bỏ không gian hàng đầu.
• diff(+y) tính toán sự khác biệt liên tiếp giữa các ký tự (để phát hiện ranh giới nhóm) ...
• ... Vì vậy, diff(find([1 diff(+y) 1])đưa ra một vectơ kích thước nhóm.
• mat2cell sau đó chia chuỗi đã sắp xếp thành các đoạn với các kích thước đó.

Toán học, 36 byte

Chức năng tích hợp Gathervà Charactersthực hiện hầu hết các công việc ở đây.

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

> <> , 49 byte

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

Rất lãng phí rộng rãi trong đầu ra, nhưng tôi cho rằng vẫn được phép đưa ra sự khoan hồng của các quy tắc

Giải trình:

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

phù hợp với một số thứ khá chặt chẽ, thậm chí sử dụng các bước nhảy để di chuyển xung quanh một số chức năng để tôi có thể chạy con trỏ theo chiều dọc.

Về cơ bản, điều này đặt mỗi ký tự ASCII trên dòng mới của chính nó và nếu không có ký tự nào tồn tại, dòng đó sẽ trống

Dùng thử trực tuyến

Chỉnh sửa: tôi đã sai, có một lỗi trong mã, điều này sẽ khiến nó không bao giờ hoàn thành nếu có một khoảng trống trong đầu vào

Bình thường, 5 byte

.gksc

Hãy thử nó ở đây!

Đưa đầu vào dưới dạng chuỗi Python (nghĩa là được gói trong dấu ngoặc kép, thoát dấu ngoặc kép và dấu gạch chéo khi cần thiết).

Giải trình:

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

Nếu bạn đảm bảo ít nhất một khoảng trống trong đầu vào, sẽ có giải pháp 4 byte:

t.gk

Hãy thử nó ở đây!

Giải trình:

 .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 byte

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

Đưa đầu vào $args[0]dưới dạng một chuỗi ký tự đối số dòng lệnh. Đóng vai trò như một char-array và sử dụng toán tử -not eQual để kéo ra khoảng trắng (ASCII 32). Điều này hoạt động vì việc truyền có quyền ưu tiên bậc cao hơn và khi một mảng được sử dụng làm toán tử bên trái với vô hướng là tay phải, nó hoạt động như một bộ lọc.

Chúng tôi chuyển mảng ký tự Group-Objectđó, chính xác những gì nó nói. Lưu ý rằng vì chúng ta chuyển các ký tự , không phải các chuỗi, nên nhóm này có phân biệt chữ hoa chữ thường.

Bây giờ, chúng ta đã có (các) đối tượng tùy chỉnh có tên nhóm, số đếm, v.v. Nếu chúng ta chỉ in rằng chúng ta sẽ có một loạt các đầu ra không liên quan. Vì vậy, chúng ta cần phải ống những thành một vòng lặp |%{...}và mỗi lần lặp -joincác .Grouplại với nhau thành một chuỗi duy nhất. Các chuỗi kết quả đó được để lại trên đường ống và đầu ra được ẩn khi hoàn thành chương trình.

Thí dụ

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

APL Dyalog , 11 byte

Chức năng trả về danh sách các chuỗi.

(⊂∩¨∪)~∘' '

(⊂∩¨∪) giao điểm của toàn bộ và các ký tự độc đáo của nó

~∘' ' ngoại trừ không gian

Dùng thử trực tuyến!

Đang xử lý, 109 byte

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;}}

Đó là cách tiếp cận vũ phu, sắp xếp mảng, sau đó lặp qua nó. Nếu nó không khớp với ký tự cuối cùng được in, trước tiên hãy in một dòng mới. Nếu đó là khoảng trắng, bỏ qua bước in.

Javascript (sử dụng Thư viện bên ngoài - Có thể đếm được) ( 78 67 byte)

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

Liên kết đến lib: https://github.com/mvegh1/Enumerable

Giải thích mã: Đây là những gì Enumerable đã được thực hiện để làm! Tải chuỗi vào thư viện, chuyển đổi nó thành một mảng char. Lọc ra các mục trắng. Nhóm bởi char. Viết mỗi nhóm vào một dòng, theo vị ngữ được chỉ định. Vị ngữ đó nói rằng hãy nối tất cả các phần tử của nhóm hiện tại thành một chuỗi, không có dấu phân cách.

MATL, 7 byte

Xz!t7XQ

Demo trực tuyến MATL

Perl6, 48 47 45

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

Nhờ manatwork cho những cải tiến.

Ruby, 46 byte

Hãy thử trực tuyến!

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

Phiên bản chương trình đầy đủ ban đầu của tôi, 48 byte sau khi thêm ncờ:

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

Con trăn, 107

Có thể rút ngắn bởi lambda, nhưng sau đó

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 byte

{S-$e`::*}

Một khối không tên dự kiến ​​chuỗi trên đầu ngăn xếp và thay thế nó bằng một danh sách các chuỗi.

Hãy thử trực tuyến!

Giải trình

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.

Lisp thường gặp, 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))

Ung dung:

(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))

Không phải là ngôn ngữ thân thiện nhất với golf. Điều này có thể được sửa đổi để trả về danh sách danh sách thay vì in chuỗi.

Emacs, 36 tổ hợp phím

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

Kết quả

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

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

Giải trình

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. Chọn dòng đầu vào;
2. Gọi sort-regexp-fieldsvới các đối số .và .;
   • Đối số # 1: Sắp xếp lại các bản ghi phân loại để sắp xếp
   • Đối số # 2: Khóa mã hóa chính quy trong hồ sơ
3. Quay trở lại khi bắt đầu dòng;
4. Áp dụng thay thế regrec \(\(.\)\2*\)-> \1\ntrên tất cả các trận đấu.