Comme la majorité des pays utilisant l'euro ont le ,séparateur décimal, vous devez également l'utiliser.

La tâche consiste à sortir toutes les valeurs des pièces et billets en euros dans l'ordre croissant. Vous devez également mettre la fin ,00sur les valeurs entières.

0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00

J'accepte les deux sorties vers stdout ou une fonction renvoyant un tableau / liste. Si la sortie est vers stdout, les séparateurs acceptables entre les valeurs sont: espace, tabulation ou retour à la ligne.

Il n'y aura pas de réponse acceptée, sauf si je vois quelqu'un que je trouve très créatif.

code-golf , donc je veux connaître la réponse la plus courte par langue.

Mise à jour:

Les 0zéros non significatifs ne sont pas acceptables. Désolé, je devrais être clair avant.

Mise à jour 2:

Il est également acceptable une fonction renvoyant une chaîne.

Pure Bash, 48

s={1,2,5}
eval echo 0,0$s 0,${s}0 ${s}{,0,00},00

Essayez-le en ligne .

Japt , 23 22 octets

-1 octet grâce à @Shaggy

5Æ#}ì ®eX-2 x2 d".,"
c

Renvoie un tableau de chaînes.

Essayez-le en ligne! avec le -Rdrapeau à des éléments de réseau de sortie sur des lignes séparées.

Python 2 , 72 octets

print[('%.2f'%(10**(x/3-2)*(5>>~x%3))).replace(*'.,')for x in range(15)]

Essayez-le en ligne!

L'expression 5>>~x%3mappe les entiers non négatifs 1, 2, 5, 1, 2, 5...

Cela fonctionne parce que 5, 2, 1sont les bons-bitshifts successives de 5( 0b101→ 0b10→ 0b1); nous les parcourons à l'envers.

Fusain , 36 octets

ＥＥ×125⁵⁺⁺×0⁻²÷κ³ι×0÷κ³⁺⁺✂ι⁰±²¦¹,✂ι±²

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

   125                                  String `125`
  ×   ⁵                                 Repeated 5 times
 Ｅ                                      Map over each character
              ÷κ³   ÷κ³                 Integer divide loop index by 3
            ⁻²                          Subtract from 2
          ×0      ×0                    Repeat the string `0` x times
        ⁺⁺       ι                      Concatenate with the character
Ｅ                                       Map over each resulting string
                         ✂ι⁰±²¦¹        Slice off the last two digits
                                ✂ι±²    Extract the last two digits
                       ⁺⁺       ,       Concatenate with a comma
                                        Implicitly print one per line

SOGLOnline offline, 27 26 25 24 23 22 21 octets

252¹5∙īυ;{⁴Ζ.,ŗP*F⁾?½

Essayez-le ici!

Le lien en ligne n'affiche pas de zéros à la fin, mais la version hors ligne fait que Javas BigDecimals est agréable.

Explication:

252¹5∙īυ;{⁴Ζ.,ŗP*F⁾?½
252¹                 push the array [2, 5, 2]
    5∙               multiply vertically by 5
      īυ;            push 0.01 below that - the main number
         {           iterate over that array - [2,5,2,2,5,2,2,5,2,2,5,2,2,5,2]
          ⁴            duplicate the main number
           Ζ.,ŗ        replace "." with ","
               P       output in a new line
                *      multiply the main number with the current item of the array
                 F⁾?   if the current array item-2 isn't 0, then
                    ½    divide by 2

POUR s'exécuter dans l'interpréteur hors ligne, téléchargez le référentiel SOGLOnlines , accédez au compilateur / interprète, ouvrez l'un des .pdefichiers avec Traitement , puis faites le fichier -> exporter pour votre système d'exploitation (sinon vous ne pouvez pas donner d'arguments à un programme de traitement: /), puis exécutez le programme compilé avec un argument sur le chemin du fichier avec le code. Ensuite, stdout contiendra ceci .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*pour 18 octets fonctionne presque mais le montant zéro augmente, ce qui entraîne 0,01 0,02 0,050 0,100 0,200 0,5000 1,0000 2,0000 5,00000 10,00000 20,00000 50,000000 100,000000 200,000000 500,0000000(les nouvelles lignes sont remplacées par des espaces)

Java 8, 109 108 81 80 octets

Merci à @ OlivierGrégoire pour l'idée Locale

x->{for(double i=.001;i<11;)System.out.printf("%.2f %.2f %.2f ",i*=10,i*2,5*i);}

Essayez-le en ligne!

Bash , 38 octets

printf %.2f\\n {1,2,5}e{-2..2}|sort -h

Nécessite un environnement local approprié, qui est autorisé par défaut et ne coûte aucun octet .

Essayez-le en ligne!

APL (Dyalog) , 30 28 octets

Programme complet. Sorties séparées par des espaces vers STDOUT.

'\.'⎕R','⊢2⍕×\.01,14⍴2 2.5 2

Essayez-le en ligne!

2 2.5 2 la liste;
 [2,2.5,2]

14⍴ cyclique r Eshape de longueur 14;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

.01 ajouter 0,01;
 [0.01,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

×\ multiplication cumulative;
 [0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500]

2⍕ format avec deux décimales;
 " 0.01 0.02 0.05 0.10 0.20 0.50 1.00 2.00 5.00 10.00 20.00 50.00 100.00 200.00 500.00"

⊢ donner que (à séparer ','de 2)

'\.'⎕R',' PCRE R Les périodes de EPlacez par des virgules;
 " 0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00"

R 70 , 50 octets

inspiré par @Giuseppe:

format(c(1,2,5)*10^rep(-2:2,e=3),ns=2,de=",",sc=F)

Essayez-le ici!

Non golfé

format(c(1,2,5)*10^rep(-2:2, each = 3),
   nsmall = 2, 
   decimal.mark = ",",
   scientific = FALSE)

Pyth , 37 octets

smmX%"%.2f"*dk\.\,[1 2 5)[.01.1 1T^T2

Essayez-le en ligne!

Pyth , 37 octets

Raccourcira dans quelques minutes.

V[.01.1 1T^T2)V[1 2 5)X%"%.2f"*NH\.\,

Essayez-le en ligne!

JavaScript (ES6), 83 octets

Renvoie un tableau.

_=>[...'125'.repeat(k=5)].map(c=>(c*(c-1?k:k*=10)/5e3).toFixed(2).split`.`.join`,`)

Démo

let f = 

_=>[...'125'.repeat(k=5)].map(c=>(c*(c-1?k:k*=10)/5e3).toFixed(2).split`.`.join`,`)

console.log(f())

Version récursive (ES7), 84 octets

Renvoie une chaîne avec un espace de fin.

f=(i=0)=>i<15?('125'[i%3]/100*10**(i/3|0)).toFixed(2).split`.`.join`,`+' '+f(i+1):''

Démo

f=(i=0)=>i<15?('125'[i%3]/100*10**(i/3|0)).toFixed(2).split`.`.join`,`+' '+f(i+1):''

console.log(f())

Python 2 , 80 77 75 73 octets

-2 octets grâce à @ Mr.Xcoder
-1 octets grâce à @EriktheOutgolfer
-2 octets grâce à @totallyhuman
-2 octets grâce à @Lynn

print[('%.2f'%(v*m)).replace(*'.,')for m in.01,.1,1,10,100for v in 1,2,5]

Essayez-le en ligne!

Rétine , 42 octets

5$*0
0
$'1$`¶$'2$`¶$'5$`¶
..¶
,$&
m`^00?

Essayez-le en ligne! Explication: Il existe quinze valeurs, avec 1, 2 et 5 à chacun des cinq emplacements. La première étape insère cinq 0. La deuxième étape les répète en carré, puis change la diagonale de fin en 1, puis duplique ces lignes trois fois avec 2 et 5. La troisième étape insère les virgules et la dernière étape supprime les zéros de tête inutiles.

Fusain , 37 octets

”{➙∧N\`�4✳×″↶tι⦄|Ｑ~(↥↗⁻“Ｑ§U‴w⎇δUη◨÷¤Ｇ”

Essayez-le en ligne! Le lien est vers la version détaillée.

Ouais, la compression!

Bash , 88 octets

s=125
for i in {0..14};{ printf %1.2f\  `bc<<<"scale=2;${s:i%3:1}*10^$[i/3-2]"`|tr . ,;}

Essayez-le en ligne!

JavaScript (ES6), 81 octets

Renvoie un tableau.

_=>[...Array(13),b=.005,i=0].map(p=>(b*=++i%3?2:2.5).toFixed(2).replace(".",","))

Démo

let f = 

_=>[...Array(13),b=.005,i=0].map(p=>(b*=++i%3?2:2.5).toFixed(2).replace(".",","))

console.log(f())

Lisp commun, 95 octets

(dotimes(i 5)(dolist(j'(1 2 5))(princ(substitute #\, #\.(format()"~$ "(*(expt 10(- i 2))j))))))

Essayez-le en ligne!

Husk , 28 octets

ṁm↔ṪöJ',CtN`J§¤eR'0≥≤2ḣ5"125

Essayez-le en ligne!

Juste une manipulation de chaîne, car Husk est terrible pour formater les nombres à virgule flottante.

Explication

ṁm↔ṪöJ',CtN`J§¤eR'0≥≤2ḣ5"125
                        "125  The string "125".
                      ḣ5      The range [1,2,3,4,5].
   Ṫö                         Compute their outer product wrt this function:
                               Arguments are number n (say 3) and character c (say '5').
             §     ≥≤2         Compute max(0,n-2+1) and max(0,2-n+1),
                R'0            repeat '0' those numbers of times,
              ¤e               and put them into a list: ["00",""]
           `J                  Join with c: "005"
        CtN                    Split to lengths 2 and at most 3: ["00","5"]
     J',                       Join with ',': "00,5"
                              This gives a 2D array of the outputs reversed.
ṁ                             Map and concatenate
 m↔                           map reversal.
                              Implicitly print separated by newlines.

C ++, 138 120 octets

-18 octets grâce à MSalters

#include<iostream>
void p(){for(auto&a:{"0,0%d ","0,%d0 ","%d,00 ","%d0,00 ","%d00,00 "})for(int b:{1,2,5})printf(a,b);}

Version codée en dur, par Lynn, 116 octets

#include<ios>
void p(){puts("0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00");}

R , 70 61 octets

options(scipen=9,OutDec=",")
print(c(1,2,5)*10^rep(-2:2,e=3))

Essayez-le en ligne!

-9 octets grâce à Rui Barradas

Outgolfed par AndriusZ

C (gcc) , 82 octets

p(n){printf("%d,%02d ",n/100,n%100);}f(n){for(n=1;n<5e4;n*=10)p(n),p(n*2),p(n*5);}

Essayez-le en ligne!

05AB1E , 25 octets

125S5иεN3÷°*т/'.',:N2›i0«

Renvoie une liste de chaînes.

Essayez-le en ligne.

Explication:

125                          # Push 125
   S                         # Split to a list of digits: [1,2,5]
    5и                       # Repeat it 5 times: [1,2,5,1,2,5,1,2,5,1,2,5,1,2,5]
      ε                      # Map each to:
       N3÷                   #  Integer-divide the map-index by 3
          °                  #  Take it to the power 10
           *                 #  Multiply the current map number with it
            т/               #  Divide it by 100
              '.',:          #  Replace all "." with ","
                   N2›i      #  And if the map-index is larger than 2:
                       0«    #   Append a "0"

125S5иpourrait être •}•15∍(push compressé 125; agrandissez-le à la taille 15:) 125125125125125et '.',:pourrait être „.,`:(push string ".,", pop et push les caractères en tant qu'éléments séparés dans la pile) pour le même nombre d'octets: Essayez-le en ligne.
En outre, N3÷°*т/peut être raccourci à N3÷Í°*(où Ísoustrait 2), mais malheureusement, nous avons besoin de /tous les nombres deviennent des décimales, alors que la N3÷Í°*plupart des nombres restent des nombres entiers.

T-SQL, 104 octets

SELECT FORMAT(p*n,'0\,00')
FROM(VALUES(1),(2),(5))a(n),(VALUES(1),(10),(100),(1E3),(1E4))b(p)
ORDER BY p,n

Les sauts de ligne sont uniquement pour la lisibilité.

Plus ennuyeux que la PRINTversion triviale (90 octets):

PRINT'0,01 0,02 0,05 0,10 0,20 0,50 1,00 2,00 5,00 10,00 20,00 50,00 100,00 200,00 500,00'

Bubblegum , 41 octets

00000000: 1dc5 8105 0040 1402 d055 1ae0 50d1 feab  .....@...U..P...
00000010: dd2f 788f 8fc2 e192 433c 5c42 e891 7049  ./x.....C<\B..pI
00000020: 11ab 67a6 b8bc 90f5 01                   ..g......

Essayez-le en ligne!

Rétine , 58 octets

¶0¶00¶000¶0000¶
.*¶
1$&2$&5$&
^
¶
+`¶(.?.?¶)
¶0$1
..¶
,$&

Essayez-le en ligne!

Rubis , 66 62 octets

-2.upto 2{|m|[1,2,5].map{|v|$><<('%.2f '.%v*10**m).tr(?.,?,)}}

4 octets de moins grâce à Lynn !

Essayez-le en ligne!

C # (.NET Core) , 107 octets

Console.Write("0,01{0}2{0}5 0,10 0,20 0,50 1{1}2{1}5{1}1{2}2{2}5{2}10{2}20{2}50{2}"," 0,0",",00 ","0,00 ");

Exécuter

JavaScript - 96 octets

x=>{for(o="",b=-2;b<3;b++)for(n of[1,2,5])o+=(n*10**b).toFixed(2).replace(".",",")+" ";return o}

Et voici une approche fonctionnelle légèrement plus longue (98 caractères):

x=>[].concat.apply([],[.01,.1,1,10,100].map(n=>[n,n*2,n*5])).map(n=>n.toFixed(2).replace(".",","))

J , 36 octets

echo'.,'charsub 0j2":,1 2 5*/~10^i:2

Essayez-le en ligne!

Tcl , 80 octets

lmap d {-2 -1 0 1 2} {lmap c {1 2 5} {puts [regsub \\. [format %.2f $c\e$d] ,]}}

Essayez-le en ligne!

lmap d {.01 .1 1 10 100} {lmap c {1 2 5} {puts [regsub \\. [format %.2f [expr $c*$d]] ,]}}

Essayez-le en ligne!

Encore très long, le golf plus tard!