Lieben Sie nicht diese Explosionszeichnungen, in denen eine Maschine oder ein Gegenstand in seine kleinsten Teile zerlegt wird?

Lass uns das mit einer Saite machen!

Die Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die

1. gibt eine Zeichenfolge ein, die nur druckbare ASCII-Zeichen enthält ;
2. zerlegt die Zeichenkette in Gruppen von Zeichen, die nicht gleich Leerzeichen sind (die "Teile" der Zeichenkette);
3. gibt diese Gruppen in einem beliebigen Format aus, wobei zwischen den Gruppen ein gewisses Trennzeichen besteht .

Zum Beispiel angesichts der Zeichenfolge

Ah, abracadabra!

Die Ausgabe wäre die folgenden Gruppen:

!
,
EIN
aaaaa
bb
c
d
h
rr

Jede Gruppe in der Ausgabe enthält gleiche Zeichen, wobei Leerzeichen entfernt werden. Als Trennzeichen zwischen den Gruppen wurde ein Zeilenvorschub verwendet. Weitere Informationen zu zulässigen Formaten finden Sie weiter unten.

Regeln

Die Eingabe sollte eine Zeichenfolge oder ein Array von Zeichen sein. Es enthält nur druckbare ASCII-Zeichen (einschließlich des Bereichs von Leerzeichen bis Tilde). Wenn Ihre Sprache dies nicht unterstützt, können Sie die Eingabe in Form von Zahlen vornehmen, die ASCII-Codes darstellen.

Sie können davon ausgehen, dass die Eingabe mindestens ein Nicht-Leerzeichen enthält .

Die Ausgabe sollte aus Zeichen bestehen (auch wenn die Eingabe über ASCII-Codes erfolgt). Es muss ein eindeutiges Trennzeichen zwischen den Gruppen geben , das sich von allen Nicht-Leerzeichen unterscheidet, die in der Eingabe erscheinen können.

Wenn die Ausgabe über Funktionsrückgabe erfolgt, kann es sich auch um ein Array oder Zeichenfolgen oder ein Array von Arrays aus Zeichen oder eine ähnliche Struktur handeln. In diesem Fall sorgt die Struktur für die notwendige Trennung.

Ein Trennzeichen zwischen den Zeichen jeder Gruppe ist optional . Wenn es eine gibt, gilt die gleiche Regel: Es darf kein Nicht-Leerzeichen in der Eingabe sein. Außerdem darf es nicht dasselbe Trennzeichen sein, das zwischen Gruppen verwendet wird.

Ansonsten ist das Format flexibel. Hier sind einige Beispiele:

• Die Gruppen können wie oben gezeigt durch Zeilenumbrüche getrennte Zeichenfolgen sein.

• Die Gruppen können durch beliebige Nicht-ASCII-Zeichen getrennt sein, z ¬. Die Ausgabe für die obige Eingabe wäre die Zeichenfolge:

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

• Die Gruppen können durch n > 1 Leerzeichen getrennt sein (auch wenn n variabel ist), wobei Zeichen zwischen jeder Gruppe durch ein einzelnes Leerzeichen getrennt sind:

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

• Die Ausgabe kann auch ein Array oder eine Liste von Zeichenfolgen sein, die von einer Funktion zurückgegeben werden:

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

• Oder ein Array von Zeichen-Arrays:

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

Beispiele für Formate, die nach den Regeln nicht zulässig sind:

• Ein Komma kann nicht als Trennzeichen ( !,,,A,a,a,a,a,a,b,b,c,d,h,r,r) verwendet werden, da die Eingabe Kommas enthalten kann.
• Es ist nicht zulässig, das Trennzeichen zwischen Gruppen ( !,Aaaaaabbcdhrr) zu löschen oder dasselbe Trennzeichen zwischen Gruppen und innerhalb von Gruppen ( ! , A a a a a a b b c d h r r) zu verwenden.

Die Gruppen können in der Ausgabe in beliebiger Reihenfolge angezeigt werden. Zum Beispiel: Alphabetische Reihenfolge (wie in den obigen Beispielen), Reihenfolge des ersten Auftretens in der Zeichenfolge, ... Die Reihenfolge muss nicht konsistent oder sogar deterministisch sein.

Beachten Sie, dass die Eingabe keine Neue - Zeile - Zeichen enthalten kann, und Aund asind verschiedene Zeichen (Gruppierung ist case-sentitive ).

Kürzester Code in Bytes gewinnt.

Testfälle

In jedem Testfall wird die erste Zeile eingegeben und die verbleibenden Zeilen werden ausgegeben, wobei sich jede Gruppe in einer anderen Zeile befindet.

• Testfall 1:

  Ah, Abrakadabra!
  !
  ,
  EIN
  aaaaa
  bb
  c
  d
  h
  rr
  

• Testfall 2:

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

• Testfall 3:

  Ein Mann, ein Plan, ein Kanal: Panama!
  !
  ,,
  :
  EIN
  P
  aaaaaaaa
  c
  ll
  mm
  nnnn
  p
  

• Testfall 4:

  "Zeig mir, wie du diesen Trick machst, der mich zum Schreien bringt", sagte sie
  ""
  ,
  S
  aaaaa
  cc
  dd
  eeeeeee
  hhhhhh
  ii
  kk
  mmmm
  n
  ooooo
  rr
  ssss
  tttttt
  u
  ww
  y
  

Gelee , 5 Bytes

ḟ⁶ṢŒg

Probieren Sie es online!

Es gibt ein Array zurück, nur dass das Trennzeichen weg ist, wenn es an STDOUT gedruckt wird.

Dies ist in der Tat eine Funktion, die als solche aufgerufen werden kann (in Jelly ist jede Zeile eine Funktion).

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

Python 3.5+, 77 46 44 41 Bytes

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

Ziemlich einfach. Durchläuft die eindeutigen Zeichen in der Zeichenfolge, indem es in eine Menge konvertiert wird (unter Verwendung des erweiterten iterierbaren Entpackens von Python 3.5), und verwendet dann ein Listenverständnis, um die explodierten Diagramme zu erstellen, indem die Häufigkeit gezählt wird, mit der jedes Zeichen in der Zeichenfolge vorkommt str.count. Wir filtern Leerzeichen heraus, indem wir sie aus der Menge entfernen.

Die Reihenfolge der Ausgabe kann von Lauf zu Lauf variieren. Sets sind ungeordnet, daher kann die Reihenfolge, in der ihre Elemente verarbeitet werden, und damit die Ausgabe dieser Antwort, nicht garantiert werden.

Dies ist ein Lambda-Ausdruck; Um es zu benutzen, setzen Sie ein Präfix lambdamit f=.

Probieren Sie es auf Ideone! Ideone verwendet Python 3.4, was nicht ausreicht.

Anwendungsbeispiel:

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

3 Bytes gespart dank @shooqie!

Retina, 13 Bytes

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

Das Sortieren ist sehr einfach (es ist ein eingebautes), es trennt die Buchstaben, die 9 Bytes benötigen. Probieren Sie es online!

Die erste Zeile enthält Oalle Übereinstimmungen des regulären Ausdrucks .(das ist jedes Zeichen), die uns geben !,Aaaaaabbcdhrr.

Übereinstimmung ist die Standardstufe für die letzte Zeile eines Programms und !bewirkt, dass eine durch Zeilenvorschub getrennte Liste der Übereinstimmungen des regulären Ausdrucks gedruckt wird. Der reguläre Ausdruck sucht nach einer oder mehreren Instanzen eines Nicht-Leerzeichens in einer Zeile.

Perl 6 , 28 Bytes

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

Beachten Sie, dass Taschen wie ein Hash oder ein Set nicht sortiert sind, sodass die Reihenfolge der Ergebnisse nicht garantiert werden kann.

Erläuterung:

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

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

Erklärung / gif kommt später.

Pyth, 6

.gk-zd

Probieren Sie es hier aus oder führen Sie eine Test Suite aus .

Ziemlich einfach, -zdentfernt Leerzeichen aus der Eingabe und .gkgruppiert jedes verbleibende Element nach seinem Wert. Leider habe ich keine Möglichkeit gefunden, automatische Füllvariablen zu verwenden. Beachten Sie, dass die Ausgabe als Python-Zeichenfolge angezeigt wird, sodass bestimmte Zeichen (mit umgekehrten Schrägstrichen) maskiert werden. Wenn Sie möchten, dass es besser lesbar ist, fügen Sie jam Anfang des Codes ein hinzu.

Haskell, 38 Bytes

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

Grundsätzlich die Lösung von nimi , aber explizit nur die in der Zeichenfolge vorkommenden Buchstaben prüfen.

2sable , 7 Bytes

Code:

Úð-vyÃ,

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

JavaScript (ES6), 41 Byte

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

Brachylog , 14 7 Bytes

7 Bytes dank Fatalize.

:@Sxo@b

Probieren Sie es online!

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

Haskell, 40 Bytes

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

Anwendungsbeispiel: f "Ah, abracadabra!"-> ["!",",","A","aaaaa","bb","c","d","h","rr"].

Das Muster v:wentspricht nur einer Liste mit mindestens einem Element, sodass alle Zeichen, die nicht in der Eingabe enthalten sind, ignoriert werden.

Auch 40 Bytes:

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

Ruby, 41 + 1 = 42 Bytes

+1 Byte für -nFlag.

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

Übernimmt Eingaben über stdin, zB:

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

C # 125 98 Bytes

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

Erläuterung

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

• Vielen Dank an @TheLethalCoder, der die Verwendung einer anonymen Funktion vorgeschlagen hat, die es mir auch ermöglichte, den ToArrayAnruf zu entfernen und nur implizit eine IEnumerable zurückzugeben, die insgesamt 27 Bytes spart

R 198 189 96 95 Bytes

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

Diese Lösung funktioniert derzeit nicht ganz, wenn \es darum geht.
Jetzt ist es !

Vielen Dank , dass eine Menge Sie @JDL für Golf aus 102 Bytes!

Swift, 105 91 Bytes

Danke an @NobodyNada für 14 Bytes :)

Ja, ich bin ziemlich neu bei Swift ...

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

Zeichen innerhalb einer Gruppe werden durch einen einzelnen Zeilenumbruch getrennt. Gruppen werden durch zwei Zeilenumbrüche getrennt.

Oktave , 61 Bytes

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

Dies ist eine nervige Funktion, die eine Zeichenfolge als Eingabe verwendet und ein Zellenarray von Zeichenfolgen ausgibt.

Versuchen Sie es bei Ideone .

Wie es funktioniert

• sortsortiert die Eingabezeichenfolge. Insbesondere werden Leerzeichen am Anfang stehen.
• strtrim Entfernt führende Leerzeichen.
• diff(+y) berechnet aufeinanderfolgende Unterschiede zwischen Zeichen (um Gruppengrenzen zu erkennen) ...
• ... diff(find([1 diff(+y) 1])ergibt also einen Vektor von Gruppengrößen.
• mat2cell teilt dann die sortierte Zeichenfolge in Abschnitte mit diesen Größen auf.

Mathematica, 36 Bytes

Eingebaute Funktionen Gatherund Characterserledigen die meiste Arbeit hier.

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

> <> 49 Bytes

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

Sehr großzügig in der Ausgabe verschwenderisch, aber ich gehe davon aus, dass es angesichts der Nachsicht der Regeln noch erlaubt ist

Erläuterung:

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

Passen Sie einige Dinge ziemlich eng an, und verwenden Sie sogar Sprünge, um einige Funktionen zu umgehen, damit ich den Zeiger vertikal bewegen kann.

Grundsätzlich wird jedes ASCII-Zeichen in eine eigene Zeile gesetzt. Wenn keines dieser Zeichen vorhanden ist, ist die Zeile leer

Probieren Sie es online aus

Bearbeiten: Ich habe mich geirrt, es gab einen Fehler im Code, der dazu führen würde, dass er niemals abgeschlossen wird, wenn sich in der Eingabe ein Leerzeichen befindet

Pyth, 5 Bytes

.gksc

Probieren Sie es hier aus!

Übernimmt die Eingabe als Python-Zeichenfolge (dh in Anführungszeichen, Anführungszeichen und Schrägstriche, falls erforderlich).

Erläuterung:

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

Wenn Sie mindestens ein Leerzeichen in der Eingabe garantieren, gibt es eine 4-Byte-Lösung:

t.gk

Probieren Sie es hier aus!

Erläuterung:

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

Nimmt Eingaben $args[0]als Literalzeichenfolge für Befehlszeilenargumente an. Wandelt das als char-array um und verwendet den Operator -not equal zum Herausziehen von Leerzeichen (ASCII 32). Dies funktioniert, weil Casting eine höhere Priorität hat und wenn ein Array als linker Operator mit einem Skalar als rechter Operator verwendet wird, wirkt es wie ein Filter.

Wir übergeben dieses Array von Zeichen an Group-Object, das genau das tut, was es sagt. Beachten Sie, dass bei der Übergabe von Zeichen und nicht von Zeichenfolgen die Groß- und Kleinschreibung berücksichtigt wird.

Jetzt haben wir ein benutzerdefiniertes Objekt, das Gruppennamen, Zählungen usw. enthält. Wenn wir nur drucken, erhalten wir eine Menge irrelevanter Ausgaben. Also müssen wir diese in einer Schleife Rohr |%{...}und jede Iteration -joindie .Groupzusammen in einem einzigen String. Diese resultierenden Zeichenfolgen verbleiben in der Pipeline, und die Ausgabe erfolgt implizit bei Programmabschluss.

Beispiel

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 Bytes

Funktion, die eine Liste von Zeichenfolgen zurückgibt.

(⊂∩¨∪)~∘' '

(⊂∩¨∪) der Schnittpunkt des Ganzen und seiner einzigartigen Charaktere

~∘' ' außer Leerzeichen

TryAPL online!

Verarbeitung, 109 Bytes

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

Sortieren Sie das Array und durchlaufen Sie es. Wenn es nicht mit dem zuletzt gedruckten Zeichen übereinstimmt, drucken Sie zuerst eine neue Zeile. Wenn es sich um ein Leerzeichen handelt, überspringen Sie den Druckschritt.

Javascript (mit externer Bibliothek - Enumerable) ( 78 67 Bytes)

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

Link zu lib: https://github.com/mvegh1/Enumerable

Code Erklärung: Dies ist, was Enumerable gemacht wurde, um zu tun! Laden Sie den String in die Bibliothek, die ihn in ein char-Array konvertiert. Filtern Sie die Leerraumeinträge heraus. Gruppieren nach char. Schreiben Sie jede Gruppe gemäß dem angegebenen Prädikat in eine Zeile. In diesem Prädikat wird angegeben, dass alle Elemente der aktuellen Gruppe ohne Begrenzer zu einer Zeichenfolge zusammengefasst werden sollen.

MATL, 7 Bytes

Xz!t7XQ

MATL Online Demo

Perl6, 48 47 45

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

Danke an manatwork für die Verbesserungen.

Ruby, 46 Bytes

Probieren Sie es online!

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

Meine ursprüngliche Vollversion, 48 Bytes nach dem Hinzufügen des nFlags:

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

Python, 107

Könnte durch Lambda verkürzt werden, aber später

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 Bytes

{S-$e`::*}

Ein unbenannter Block, der die Zeichenfolge über dem Stapel erwartet und durch eine Liste von Zeichenfolgen ersetzt.

Probieren Sie es online!

Erläuterung

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.

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

Nicht die golffreundlichste Sprache. Dies könnte möglicherweise geändert werden, um eine Liste von Listen zurückzugeben, anstatt eine Zeichenfolge zu drucken.

Emacs, 36 Tastenanschläge

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

Ergebnis

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

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

Erläuterung

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. Wählen Sie die Eingabezeile aus.
2. Aufruf sort-regexp-fieldsmit Argumenten .und .;
   • Argument 1: Regexp scpecifying records to sort
   • Argument 2: Regexp scpecifying key within records
3. Rückkehr am Zeilenanfang;
4. Regexp-Substitution anwenden \(\(.\)\2*\)-> \1\nbei allen Übereinstimmungen.