Bir makinenin veya nesnenin en küçük parçalarına bölündüğü patlamış görünüm diyagramlarını sevmiyor musunuz ?

Bunu bir dizeye yapalım!

Meydan okuma

Bir program veya fonksiyon yazmak

1. yalnızca yazdırılabilir ASCII karakterlerini içeren bir dize girdi ;
2. dizgiyi boşluk olmayan eşit karakter gruplarına ( dizginin "parçaları") ayırır;
3. Bu grupları, gruplar arasında bir ayırıcıyla , uygun herhangi bir biçimde çıkarır .

Örneğin, dize verilen

Ah, abracadabra!

çıktı aşağıdaki gruplar olacaktır:

!
,
bir
aaaaa
bb
c
d
h
rr

Çıktıdaki her grup, boşluk kaldırılmış olarak eşit karakterler içerir. Gruplar arasında ayırıcı olarak bir newline kullanılmıştır. Aşağıdaki izin verilen biçimler hakkında daha fazla bilgi.

kurallar

Giriş , bir ip ya da karakter dizisi olmalıdır. Yalnızca yazdırılabilir ASCII karakterlerini içerecektir (uzaydan tilde dahil olan). Diliniz bunu desteklemiyorsa, girişi ASCII kodlarını temsil eden sayılar şeklinde alabilirsiniz.

Girişin en az bir boşluk olmayan karakter içerdiğini varsayabilirsiniz .

Çıkış oluşmalıdır karakter (giriş ASCII kod vasıtasıyla olsa bile). Girişte görünebilecek boşluk olmayan karakterlerden farklı olarak gruplar arasında belirsiz bir ayırıcı olmalıdır .

Çıktı, işlev dönüşü üzerinden gerçekleştiriliyorsa, bir dizi veya dizeler veya bir karakter dizisi dizisi veya benzer bir yapı da olabilir. Bu durumda yapı gerekli ayrımı sağlar.

Her grubun karakterleri arasında bir ayırıcı isteğe bağlıdır . Bir kural varsa, aynı kural geçerlidir: girişte görünebilecek boşluk olmayan bir karakter olamaz. Ayrıca, gruplar arasında kullanılanla aynı ayırıcı olamaz.

Bunun dışında format esnek. İşte bazı örnekler:

• Gruplar yukarıda gösterildiği gibi yeni satırlarla ayrılmış dizeler olabilir.

• Gruplar, gibi ASCII olmayan herhangi bir karakterle ayrılabilir ¬. Yukarıdaki giriş için çıktı dizge olacaktır:

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

• Gruplar n > 1 boşluklarla ayrılabilir ( n değişken olsa bile ), her grup arasındaki karakter sayısı tek bir boşlukla ayrılabilir:

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

• Çıktı, bir işlev tarafından döndürülen bir dize dizisi veya listesi de olabilir:

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

• Veya bir dizi char dizisi:

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

Kurallara göre izin verilmeyen format örnekleri:

• !,,,A,a,a,a,a,a,b,b,c,d,h,r,rGirdi virgül içerebileceğinden virgül ayırıcı ( ) olarak kullanılamaz .
• Ayırıcıyı gruplar ( !,Aaaaaabbcdhrr) arasına düşürmek veya aynı ayırıcıyı gruplar arasında ve gruplar içinde ( ! , A a a a a a b b c d h r r) kullanmak kabul edilmez .

Gruplar çıktıda herhangi bir sırada görünebilir . Örneğin: alfabetik sıra (yukarıdaki örneklerde olduğu gibi), dizedeki ilk görünüm sırası, ... Düzenin tutarlı veya hatta deterministik olması gerekmez.

Girdilerin yeni satır karakterleri içeremediğiniA ve afarklı karakterler olduklarını unutmayın (gruplama büyük / küçük harfe duyarlıdır ).

Bayt cinsinden en kısa kod kazanır.

Test durumları

Her test durumunda, ilk satır giriş ve kalan satırlar her grup farklı bir satırda çıktı olarak verilir.

• Test durumu 1:

  Ah, abrakadabra!
  !
  ,
  bir
  aaaaa
  bb
  c
  d
  h
  rr
  

• Test durumu 2:

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

• Test durumu 3:

  Bir adam, bir plan, bir kanal: Panama!
  !
  ,,
  :
  bir
  P
  aaaaaaaaa
  c
  ll
  aa
  nnnn
  p
  

• Test durumu 4:

  “Bana bu numarayı nasıl yaptığını göster, beni çığlık atan şey”
  ""
  ,
  S
  aaaaa
  cc
  gg
  eeeeeee
  hhhhhh
  ii
  kK
  mmmm
  n
  ooooo
  rr
  ssss
  tttttt
  u
  ww
  y
  

Jöle , 5 bayt

ḟ⁶ṢŒg

Çevrimiçi deneyin!

Bir dizi döndürür, tam olarak STDOUT'a yazdırıldığında, ayırıcı gitti.

Bu gerçekten denebilecek bir fonksiyonudur gibi (jöle, her çizgi bir fonksiyonudur).

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

Python 3.5+, 77 46 44 41 bayt

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

Oldukça basit. Dizideki benzersiz karakterleri bir kümeye dönüştürerek geçer (Python 3.5'in genişletilmiş yinelenebilir paketini açma özelliğini kullanarak), ardından dizgede her karakterin kaç tane olduğunu sayarak patlayan diyagramları oluşturmak için bir liste kavrama kullanır str.count. Boşlukları kümeden çıkararak filtreleriz.

Çıktının sırası, çalışmadan çalışmaya değişebilir; setleri sıralı değildir, bu nedenle öğelerinin işlenme sırası ve dolayısıyla bu cevabın çıktıları garanti edilemez.

Bu bir lambda ifadesidir; , öneki kullanmak lambdaile f=.

Ideone'da dene! Ideone Python 3.4'ü kullanıyor, bu yeterli değil.

Kullanım örneği:

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

@Shooqie sayesinde 3 bayt kaydedildi!

Retina, 13 bayt

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

Sıralama çok kolaydır (bir yerleşiktir), 9 bayt süren harfleri ayırır. Çevrimiçi deneyin!

İlk satır, Oregex'in tüm eşleşmelerini .(her karakter olan) bize verir !,Aaaaaabbcdhrr.

Eşleşme, bir programın son satırı için varsayılan aşamadır ve !satır düzeniyle ayrılan eşleşmelerin bir listesini yazdırır. Düzenli ifade, bir satırdaki boşluksuz bir karakterin bir veya daha fazla örneğini arar.

Perl 6 , 28 bayt

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

O Not Çanta bir benzeri Hash veya Set sonuçlarının sırası garanti edilmez böylece sırasız olduğunu.

Açıklama:

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

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

Açıklama / gif daha sonra gelecek.

Pyth, 6

.gk-zd

Burada deneyin veya bir Test Suite çalıştırın .

Oldukça basit, -zdgirdideki boşlukları kaldırır ve .gkkalan her öğeyi değerine göre gruplandırır. Ne yazık ki, otomatik doldurma değişkenlerini kullanmanın bir yolunu bulamadım. Çıktının Python dizeleri olarak gösterildiğini, bu nedenle bazı karakterlerin (read: ters eğik çizgi) kaçtığını unutmayın. Daha okunaklı olmasını istiyorsanız j, kodun başına bir a ekleyin .

Haskell, 38 bayt

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

Temel olarak nimi'nin çözümü , ancak açıkça dizgede görünen harfleri kontrol ediyorum .

2sable , 7 bayt

Kod:

Úð-vyÃ,

Açıklama:

Ú       # 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 kodlamasını kullanır . Çevrimiçi deneyin!

JavaScript (ES6), 41 bayt

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

Brachylog , 14 7 bayt

Fatalize sayesinde 7 bayt.

:@Sxo@b

Çevrimiçi deneyin!

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

Haskell, 40 bayt

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

Kullanım örneği: f "Ah, abracadabra!"->["!",",","A","aaaaa","bb","c","d","h","rr"] .

Desen v:w sadece en az bir element içeren listeyle eşleşir, bu nedenle girişte bulunmayan tüm karakterler dikkate alınmaz.

Ayrıca 40 bayt:

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

Ruby, 41 + 1 = 42 bayt

-nBayrak için +1 bayt .

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

Stdin'e girdi, örneğin:

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

C # 125 98 Bayt

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

açıklama

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

• Anonim bir işlevin kullanılmasını öneren @TheLethalCoder sayesinde bu ToArrayçağrıyı kaldırmamı ve toplu olarak 27 bayt kazandıran bir IEnumerable döndürmemi sağladı.

R, 198 189 96 95 bayt

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

Bu çözüm, \söz konusu olduğunda şu anda tamamen çalışmıyor .
Şimdi öyle!

102 byte'ı attığınız için @JDL'ye çok teşekkürler !

Swift, 105 91 bayt

14 byte için @NobodyNada'ya teşekkürler :)

Evet, Swift için oldukça yeniyim ...

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

Bir grup içindeki karakterler tek bir yeni satırla ayrılır. Gruplar iki yeni satırla ayrılır.

Oktav , 61 bayt

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

Bu, bir dizgeyi girdi olarak alan ve dizgelerin hücre dizisini çıkaran çok büyük bir işlevdir.

Ideone'da dene .

Nasıl çalışır

• sortgiriş dizesini sıralar. Özellikle, boşluklar başlangıçta olacak.
• strtrim baştaki boşlukları kaldırır.
• diff(+y) karakterler arasındaki ardışık farkları hesaplar (grup sınırlarını tespit etmek için) ...
• ... böylece diff(find([1 diff(+y) 1])grup büyüklüğünün bir vektörünü verir.
• mat2cell daha sonra sıralanmış dizeyi bu boyutlardaki topaklara böler.

Mathematica, 36 bayt

Yerleşik işlevler Gatherve Charactersburada işlerin çoğunu yapın.

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

> <> , 49 bayt

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

Çıktıda çok geniş bir israf var, ancak kurallara uyulmadığı halde hala izin verildiğini kabul ediyorum.

Açıklama:

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

işaretçiyi dikey olarak çalıştırabilmem için bazı işlevlere oldukça sıkı oturtuluyor, hatta bazı işlevlerin etrafında dolaşmak için atlamalar kullanılıyor.

Temel olarak bu, her ASCII karakterini kendi yeni satırına yerleştirir ve bu karakterlerden hiçbiri yoksa, satır boş kalır.

Çevrimiçi deneyin

Düzenleme: yanlıştı kod girişinde bir boşluk olsaydı asla tamamlanmasına neden olur bir hata oluştu

Pyth, 5 bayt

.gksc

Burada dene!

Girdiyi bir Python dizgisi olarak alır (yani tırnaklara sarılır, tırnaklardan kaçar ve gerektiği gibi eğik çizgi alır).

Açıklama:

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

Girişte en az bir boşluk garanti ederseniz, 4 baytlık bir çözüm vardır:

t.gk

Burada dene!

Açıklama:

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

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

Girdiyi $args[0]komut satırı argümanı değişmez dizge olarak alır. char-Array olarak yayınlar ve -not kullanıre Qual operatör boşluk çekmeyi (ASCII32 ). Bu, dökümün daha yüksek bir öncelik önceliğine sahip olduğu ve sağ dizi gibi skalerli bir sol operatör olarak bir dizi kullanıldığında, bir filtre gibi davrandığı için çalışır.

Bu karakter dizisine Group-Objecttam olarak ne diyorsa onu iletiriz. Not ettiğimizden beriKarakterleri dizileri yerine , bunun doğru şekilde büyük / küçük harf duyarlılığı ile gruplandığını unutmayın.

Şimdi, grup adları, sayımları vb. Olan özel bir nesne / nesnelerimiz var. Yani, biz borusuna bir döngüye bu ihtiyaç |%{...}iterasyon ve her-join.Group tek bir dize halinde bir araya. Elde edilen bu dizgiler boru hattında bırakılır ve çıktı programın tamamlanmasında gizlidir.

Örnek

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 bayt

Dönen dizgelerin fonksiyonu.

(⊂∩¨∪)~∘' '

(⊂∩¨∪) bütünlük ve benzersiz karakterlerin kesişimi

~∘' ' boşluklar hariç

TryAPL çevrimiçi!

İşlem, 109 bayt

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

Bu kaba kuvvet yaklaşımı, diziyi sıralayın, sonra döngüden geçirin. Yazdırılan son karakterle eşleşmezse, önce yeni bir satır yazdırın. Boşsa, yazdırma adımını atlayın.

Javascript (harici Kitaplığı kullanarak - Numaralandırılabilir) ( 78 67 bayt)

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

Lib bağlantısı: https://github.com/mvegh1/Enumerable

Kod açıklaması: Bu numaralandırılabilir yapmak için yapıldı! Dize, char karakterine dönüştüren kütüphaneye yükleyin. Beyaz boşluk girişlerini filtreleyin. Char tarafından grup. Her grubu belirtilen yüklemeye göre bir satıra yazın. Bu belirtici, geçerli grubun tüm öğelerini sınırlayıcı olmadan bir dizgiye eklemeyi söylüyor.

MATL, 7 bayt

Xz!t7XQ

MATL Çevrimiçi Demo

Perl 6, 48 47 45

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

Gelişmeler için manatwork sayesinde.

Ruby, 46 bayt

Çevrimiçi deneyin!

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

Orijinal tam program sürümüm, nbayrağını ekledikten sonra 48 bayt :

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

Python, 107

Lambda tarafından kısaltılabilir, ancak daha sonra

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 bayt

{S-$e`::*}

Dizenin yığının en üstünde bekleyen ve dizelerin bir listesi ile değiştirildiği adlandırılmamış bir blok.

Çevrimiçi deneyin!

açıklama

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.

Ortak Lisp, 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))

En golf dostu dil değil. Bu muhtemelen baskı dizesi yerine liste listesini döndürmek için değiştirilebilir.

Emacs, 36 tuş vuruşlarını

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

Sonuç

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

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

açıklama

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. Giriş hattını seçin;
2. sort-regexp-fieldsArgümanlar ile arayın .ve. ;
   • Değişken # 1: Sıralanacak kayıtları tanımlayan Regexp
   • Bağımsız Değişken # 2: Kayıtlar içindeki Regexp kodlama anahtarı
3. Satır başlangıcında dönüş;
4. Tüm maçlarda regexp oyuncu değişikliği uygulayın \(\(.\)\2*\)-> \1\n.