Connexe: Valider un tracé tige-feuille

Contribution

Une liste non vide d'entiers positifs. Si nécessaire, ils peuvent être considérés comme des chaînes. Vous ne pouvez pas supposer qu'il est trié.

Production

Un graphique tige-et-feuille des nombres. Dans un ce diagramme à tiges et à feuilles, les numéros sont commandés dans les tiges par des dizaines, puis tous les numéros qui entrent dans cette tige ont leur celles valeur passée dans la tige, puis tous sont triés. Dans ce défi, les nouvelles lignes séparent les tiges et les espaces séparent les tiges des feuilles.

Vous pouvez inclure ou exclure toutes les tiges vides situées entre des tiges non vides.

Cas de test

(les listes peuvent être prises dans la liste par défaut de votre langue, j'ai utilisé JSON pour le ci-dessous)

Y compris les tiges vides:

[1, 2, 3, 3, 3, 3, 3, 10, 15, 15, 18, 1, 100]

0 11233333
1 0558
2
3
4
5
6
7
8
9
10 0

[55, 59, 49, 43, 58, 59, 54, 44, 49, 51, 44, 40, 50, 59, 59, 59]

4 034499
5 0145899999

[10000, 10100]

1000 0
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010 0

Hors tiges vides:

[1, 2, 3, 3, 3, 3, 3, 10, 15, 15, 18, 1, 100]

0 11233333
1 0558
10 0

[55, 59, 49, 43, 58, 59, 54, 44, 49, 51, 44, 40, 50, 59, 59, 59]

4 034499
5 0145899999

[10000, 10100]

1000 0
1010 0

R , 12 octets

stem(scan())

Essayez-le en ligne!

Explication:

s               # imports RAND's "Million Random Digits"
  e  )          # cooks a pound of spaghetti and places it on the stack
 t              # transposes the output 42 times
       can      # goes for a pee
   m(           # grows moustache, turns head to side and frowns
      s   (     # implicitly ignores all criticism
           )    # makes a stemplot of the input

Gelée , 17 octets

Ṣµ:©⁵Ġṁ@%⁵®Q¤żK€Y

Essayez-le en ligne!

Python 2 , 78 75 79 octets

s=-1
for i in sorted(input()):
 if i/10^s:s=i/10;print'\n%d-'%s,
 print`i`[-1],

Essayez-le en ligne!

Rétine , 38 30 octets

Merci à Neil d'avoir sauvé 2 octets et à Leo d'avoir sauvé 6 autres.

Le nombre d'octets suppose un codage ISO 8859-1.

O#`
.\b
 $&
\B 
0 
D$`¶?.+ 
$*

L'entrée est une liste d'entiers séparés par des sauts de ligne. La sortie omet les préfixes vides.

Essayez-le en ligne!

JavaScript (ES6), 89 octets

a=>a.sort((a,b)=>a-b).map(e=>r[d=e/10|0]=(r[d]||d+` `)+e%10,r=[])&&r.filter(e=>e).join`
`

Python 2 , 146 140 133 124 120 118 109 107 90 86 84 91 82 81 70 63 octets

-6 octets grâce à Rod. -9 octets grâce aux ovs.

lambda l:{i/10:[j%10for j in sorted(l)if j/10==i/10]for i in l}

Essayez-le en ligne!

D'accord, quelque chose est légèrement bancal. Comme tous les programmeurs Python doivent le savoir, les dict ne sont pas ordonnés, ce qui signifie que l'ordre d'origine des paires clé-valeur n'est pas conservé. Cependant, dans mon code actuel, je ne trie pas du tout le dict résultant. Pourtant, j'ai testé plusieurs fois, en vérifiant l'égalité et l'ordre à chaque fois, et le dict sort toujours bien. Si quelqu'un réfute que cela se passe toujours bien ou sait pourquoi cela fonctionne, j'aimerais savoir.

Entrez sous forme de liste python et sortez sous forme de dict. Exemple:

Contribution:

[1, 2, 3, 3, 3, 3, 3, 10, 15, 15, 18, 1, 100]

Production:

{0: [1, 1, 2, 3, 3, 3, 3, 3], 1: [0, 5, 5, 8], 10: [0]}

Mathematica, 103 octets

Code extrait de la réponse supprimée de @ user202729

Grid[Table[{Keys[#][[i]],""<>ToString/@#[[i]]},{i,Length@#}]]&@(GroupBy[Sort@#,⌊#/10⌋&]~Mod~10&@#)&

> <> , 84 octets

1&0\n~a7+3.
 :}<$?)@:$@:v!?
r~&^?-l&:+1&/&:,a-%a::
&=?v~&1+:&ao>n" "o:?!;::a%:@-a,&:

Essayez-le en ligne ou au terrain de jeux de poissons !

Suppose que les numéros d'entrée sont déjà sur la pile .

Explication: Tout d'abord, nous trions la pile à l'aide d'un tri à bulles , avec ce morceau de code:

1&0\
 :}<$?)@:$@:v!?
   ^?-l&:+1&/

Ensuite, nous calculons le quotient entier de la première chose dans la pile en utilisant 10 ::a%-a,, le mettons dans le registre et parcourons la pile en imprimant les derniers chiffres des nombres jusqu'à ce que leurs premiers chiffres ne soient pas les mêmes que le registre, puis incrémenter le registre et continuer. Lorsque nous atteignons la fin de la liste, marquée d'un 0, nous nous arrêtons.

PostgreSQL, 53 octets

SELECT n/10,json_agg(n%10ORDER BY n)FROM t GROUP BY 1

La liste des entiers doit résider dans une integercolonne nd'une table existante t. Le résultat est un tableau à deux colonnes: chaque ligne se compose d'une colonne "tige" et d'une colonne "feuilles". La colonne "feuilles" est au format tableau JSON. (Comme indiqué dans les commentaires, il n'est pas nécessaire de respecter exactement le format indiqué sous "Cas de test".)

Bien que l'ordre des tiges ne soit pas garanti (pour économiser 10 octets, il ORDER BY 1est omis à la fin de la requête), lors de mes tests, les tiges semblaient se retrouver dans le bon ordre.

Afficher le résultat sur SQL Fiddle