Vous n'aimez pas ces schémas à vues éclatées dans lesquels une machine ou un objet est démonté en ses plus petites pièces?

Faisons cela à une chaîne!

Le défi

Écrivez un programme ou une fonction qui

1. saisit une chaîne contenant uniquement des caractères ASCII imprimables ;
2. dissèque la chaîne en groupes de caractères égaux sans espace (les "morceaux" de la chaîne);
3. affiche ces groupes dans un format pratique, avec un séparateur entre les groupes .

Par exemple, étant donné la chaîne

Ah, abracadabra!

le résultat serait les groupes suivants:

!
,
UNE
aaaaa
bb
c
ré
h
rr

Chaque groupe de la sortie contient des caractères égaux, avec des espaces supprimés. Une nouvelle ligne a été utilisée comme séparateur entre les groupes. Plus d'informations sur les formats autorisés ci-dessous.

Règles

L' entrée doit être une chaîne ou un tableau de caractères. Il ne contiendra que des caractères ASCII imprimables (la plage comprise de l'espace au tilde). Si votre langue ne le supporte pas, vous pouvez saisir les données sous forme de nombres représentant des codes ASCII.

Vous pouvez supposer que l'entrée contient au moins un caractère autre que l'espace .

La sortie doit être composée de caractères (même si l'entrée est au moyen de codes ASCII). Il doit exister un séparateur non ambigu entre les groupes , différent de tout caractère non-espace pouvant apparaître dans l'entrée.

Si la sortie est renvoyée via la fonction return, il peut également s'agir d'un tableau ou de chaînes, ou d'un tableau de tableaux de caractères, ou d'une structure similaire. Dans ce cas, la structure fournit la séparation nécessaire.

Un séparateur entre les caractères de chaque groupe est facultatif . S'il en existe un, la même règle s'applique: il ne peut s'agir d'un caractère non espace qui puisse apparaître dans l'entrée. En outre, il ne peut pas s'agir du même séparateur que celui utilisé entre les groupes.

Autre que cela, le format est flexible. Voici quelques exemples:

• Les groupes peuvent être des chaînes séparées par des lignes, comme indiqué ci-dessus.

• Les groupes peuvent être séparés par tout caractère non-ASCII, tel que ¬. La sortie pour l'entrée ci-dessus serait la chaîne:

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

• Les groupes peuvent être séparés par n > 1 espaces (même si n est variable), avec des caractères entre chaque groupe séparés par un seul espace:

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

• La sortie peut également être un tableau ou une liste de chaînes renvoyées par une fonction:

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

• Ou un tableau de tableaux de caractères:

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

Exemples de formats non autorisés selon les règles:

• Une virgule ne peut pas être utilisée comme séparateur ( !,,,A,a,a,a,a,a,b,b,c,d,h,r,r), car l'entrée peut contenir des virgules.
• Il n'est pas accepté de supprimer le séparateur entre groupes ( !,Aaaaaabbcdhrr) ou d'utiliser le même séparateur entre groupes et au sein de groupes ( ! , A a a a a a b b c d h r r).

Les groupes peuvent apparaître dans n'importe quel ordre dans la sortie. Par exemple: ordre alphabétique (comme dans les exemples ci-dessus), ordre de première apparition dans la chaîne, ... L'ordre n'a pas besoin d'être cohérent ni même déterministe.

Notez que l'entrée ne doit pas contenir de caractères de nouvelle ligne, et Ail as'agit de caractères différents (le groupement est sensible à la casse ).

Le code le plus court en octets gagne.

Cas de test

Dans chaque cas de test, la première ligne est entrée et les lignes restantes sont la sortie, chaque groupe se trouvant sur une ligne différente.

• Cas de test 1:

  Ah, abracadabra!
  !
  ,
  UNE
  aaaaa
  bb
  c
  ré
  h
  rr
  

• Cas de test 2:

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

• Cas de test 3:

  Un homme, un plan, un canal: Panama!
  !
  ,,
  :
  UNE
  P
  aaaaaaaaa
  c
  ll
  mm
  nnnn
  p
  

• Cas de test 4:

  "Montre-moi comment tu fais ce tour, celui qui me fait crier" dit-elle
  ""
  ,
  S
  aaaaa
  cc
  jj
  eeeeeee
  hhhhhh
  ii
  kk
  mmmm
  n
  ooooo
  rr
  ssss
  tttttt
  vous
  ww
  y
  

Gelée , 5 octets

ḟ⁶ṢŒg

Essayez-le en ligne!

Il renvoie un tableau, mais le séparateur a disparu lorsqu'il est imprimé sur STDOUT.

C'est en effet une fonction qui peut être appelée en tant que telle (dans Jelly, chaque ligne est une fonction).

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

Python 3.5+, 77 46 44 41 octets

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

Assez simple. Parcourt les caractères uniques de la chaîne en les convertissant en un ensemble (à l'aide de la décompression itérative étendue de Python 3.5), puis utilise une liste de compréhension pour construire les diagrammes éclatés en comptant le nombre d'occurrences de chaque caractère dans la chaîne avecstr.count . Nous filtrons les espaces en les supprimant de l'ensemble.

L'ordre des sorties peut varier d'une exécution à l'autre. les ensembles ne sont pas ordonnés. L'ordre dans lequel leurs éléments sont traités, et donc cette réponse, ne peut pas être garanti.

Ceci est une expression lambda; l'utiliser, préfixe lambdaavec f=.

Essayez-le sur Ideone! Ideone utilise Python 3.4, ce qui n’est pas suffisant.

Exemple d'utilisation:

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

3 octets sauvés grâce à @shooqie!

Retina, 13 octets

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

Le tri est très facile (c'est une commande intégrée), c'est une séparation des lettres qui prend 9 octets. Essayez-le en ligne!

La première ligne Oaffiche toutes les correspondances de la regex .(ce qui représente chaque caractère) !,Aaaaaabbcdhrr.

Match est l'étape par défaut pour la dernière ligne d'un programme et lui !permet d'imprimer une liste de correspondances de l'expression régulière séparées par des sauts de ligne. L'expression rationnelle recherche une ou plusieurs occurrences d'un caractère autre que l'espace dans une ligne.

Perl 6 , 28 octets

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

Notez que Sac, comme un hachage ou un jeu, n'est pas ordonné. L'ordre des résultats n'est donc pas garanti.

Explication:

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

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

Explication / gif viendra plus tard.

Pyth, 6

.gk-zd

Essayez-le ici ou lancez une suite de tests .

Assez simple, -zdsupprime les espaces de l'entrée et .gkregroupe chaque élément restant en fonction de sa valeur. Malheureusement, je n'ai pas trouvé le moyen d'utiliser des variables à remplissage automatique. Notez que la sortie est affichée sous forme de chaînes Python, de sorte que certains caractères (lecture: barres obliques inverses) sont échappés. Si vous voulez qu'il soit plus lisible, ajoutez a jau début du code.

Haskell, 38 octets

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

Fondamentalement, la solution de nimi , mais en vérifiant explicitement uniquement les lettres apparaissant dans la chaîne.

2sable , 7 bytes

Code:

Úð-vyÃ,

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

JavaScript (ES6), 41 octets

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

Brachylog , 14 à 7 octets

7 octets grâce à Fatalize.

:@Sxo@b

Essayez-le en ligne!

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

Haskell, 40 octets

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

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

Le modèle v:wcorrespond uniquement à la liste avec au moins un élément, de sorte que tous les caractères ne figurant pas dans l'entrée sont ignorés.

Aussi 40 octets:

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

Ruby, 41 + 1 = 42 octets

+1 octet pour le -ndrapeau.

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

Prend une entrée sur stdin, par exemple:

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

C # 125 98 octets

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

Explication

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

• Merci à @TheLethalCoder qui a suggéré l'utilisation d'une fonction anonyme, ce qui m'a également permis de supprimer l' ToArrayappel et de renvoyer implicitement un IEnumerable qui enregistre 27 octets collectivement.

R, 198 189 96 95 octets

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

Cette solution ne fonctionne pas entièrement à l'heure actuelle \.
C'est maintenant !

Merci beaucoup à @JDL pour avoir joué 102 octets!

Rapide, 105 à 91 octets

Merci à @NobodyNada pour 14 octets :)

Oui, je suis assez nouveau pour Swift ...

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

Les caractères d'un groupe sont séparés par une nouvelle ligne. Les groupes sont séparés par deux nouvelles lignes.

Octave , 61 octets

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

C'est une fonction anormale qui prend une chaîne en tant qu'entrée et génère un tableau de cellules de chaînes.

Essayez chez Ideone .

Comment ça marche

• sorttrie la chaîne d'entrée. En particulier, les espaces seront au début.
• strtrim supprime les espaces de début.
• diff(+y) calcule les différences consécutives entre les caractères (pour détecter les limites du groupe) ...
• ... donc diff(find([1 diff(+y) 1])donne un vecteur de taille de groupe.
• mat2cell divise ensuite la chaîne triée en morceaux avec ces tailles.

Mathematica, 36 octets

Fonctions intégrées Gatheret Charactersfaire la plupart du travail ici.

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

> <> , 49 octets

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

Très volumineux gaspillage dans la sortie, mais je suppose est toujours autorisé étant donné la clémence des règles

Explication:

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

adapter certaines choses dans serré, même en utilisant des sauts pour contourner certaines fonctions afin que je puisse exécuter le pointeur verticalement.

Fondamentalement, cela met chaque caractère ASCII sur sa propre nouvelle ligne, et si aucun de ce caractère n'existe, la ligne sera vide

Essayez-le en ligne

Edit: je me suis trompé, il y avait une erreur dans le code qui le ferait ne jamais se terminer s'il y avait un espace dans l'entrée

Pyth, 5 octets

.gksc

Essayez-le ici!

Prend l'entrée en tant que chaîne Python (c'est-à-dire entourée de guillemets, de guillemets et de barres obliques si nécessaire).

Explication:

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

Si vous garantissez au moins un espace dans l'entrée, il existe une solution à 4 octets:

t.gk

Essayez-le ici!

Explication:

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

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

Prend l'entrée en $args[0]tant que chaîne littérale d'argument de ligne de commande. Transmet cela comme un chartableau, et utilise l' opérateur -not equal pour extraire des espaces (ASCII32 ). Cela fonctionne parce que la conversion a une priorité supérieure et que, lorsqu'un tableau est utilisé comme opérateur de gauche avec un scalaire de droite, il agit comme un filtre.

Nous passons ce tableau de caractères à Group-Object, qui fait exactement ce qu'il dit. Notez que puisque nous passons des personnages et non des chaînes, cela regroupe correctement les caractères en respectant la casse.

Maintenant, nous avons un ou plusieurs objets personnalisés qui ont des noms de groupe, des comptes, etc. Si nous imprimons simplement, nous aurions une foule de sorties superflues. Donc, nous devons canaliser ceux-ci dans une boucle |%{...}et chaque itération-join l' .Groupensemble en une seule chaîne. Ces chaînes résultantes sont laissées sur le pipeline et la sortie est implicite à l'achèvement du programme.

Exemple

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 octets

Fonction renvoyant la liste des chaînes.

(⊂∩¨∪)~∘' '

(⊂∩¨∪) l'intersection de l'ensemble et ses personnages uniques

~∘' ' sauf les espaces

TryAPL en ligne!

Traitement, 109 octets

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

C'est l'approche de la force brute, trier le tableau, puis le parcourir en boucle. S'il ne correspond pas au dernier caractère imprimé, imprimez d'abord une nouvelle ligne. S'il s'agit d'un espace, ignorez l'étape d'impression.

Javascript (en utilisant une bibliothèque externe - Enumerable) ( 78 67 octets)

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

Lien vers lib: https://github.com/mvegh1/Enumerable

Explication de code: C’est ce qu’Enumerable a été fait de faire! Chargez la chaîne dans la bibliothèque, qui la convertit en tableau de caractères. Filtrer les entrées d'espace blanc. Groupe par caractère. Ecrivez chaque groupe sur une ligne, en fonction du prédicat spécifié. Ce prédicat dit de joindre tous les éléments du groupe actuel dans une chaîne, sans délimiteur.

MATL, 7 octets

Xz!t7XQ

Démo en ligne MATL

Perl6, 48 47 45

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

Merci à manatwork pour les améliorations.

Ruby, 46 octets

Essayez-le en ligne!

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

Ma version complète du programme d'origine, 48 octets après l'ajout de l' nindicateur:

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

Python, 107

Peut être raccourci par lambda, mais plus tard

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 octets

{S-$e`::*}

Un bloc sans nom qui attend la chaîne au-dessus de la pile et la remplace par une liste de chaînes.

Essayez-le en ligne!

Explication

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

Pas la langue la plus amicale au golf. Cela pourrait probablement être modifié pour renvoyer une liste de listes plutôt que d'imprimer une chaîne.

Emacs, 36 frappes au clavier

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

Résultat

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

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

Explication

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. Sélectionnez la ligne d'entrée.
2. Appel sort-regexp-fieldsavec arguments .et. ;
   • Argument n ° 1: Expression rationnelle spécifiant les enregistrements à trier
   • Argument n ° 2: Expression rationnelle de la clé de spécification dans les enregistrements
3. Retour au début de la ligne;
4. Appliquez la substitution d'expressions rationnelles \(\(.\)\2*\)-> \1\nsur tous les matches.