Euro'yu kullanan ülkelerin çoğunluğunun ,ondalık ayırıcı olduğu gibi, bunu da kullanmalısınız.

Görev Euro madeni paralarının ve değerlerinin tüm değerlerini artan düzende vermektir. İzlemeyi ,00tam sayı değerlerine de koymalısınız .

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

Hem çıktıyı stdout'a ya da bir dizi / liste döndüren bir fonksiyona kabul ediyorum. Çıktı stdout ise, değerler arasındaki kabul edilebilir ayırıcılar: boşluk, sekme veya yeni satır.

Çok yaratıcı bulduğum bir tanesini görmezsem, kabul edilmiş bir cevap olmayacak.

kod-golf , bu yüzden dile göre en kısa cevabı bilmek istiyorum.

Güncelleştirme:

Öne çıkan 0sıfırlar kabul edilemez. Üzgünüm, daha önce netleştirmeliyim.

Güncelleme 2:

Aynı zamanda bir string döndüren bir fonksiyon da kabul edilebilir.

Saf Baş, 48

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

Çevrimiçi deneyin .

Japt , 23 22 bayt

@Shaggy sayesinde -1 bayt

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

Bir dizi dizeyi döndürür.

Çevrimiçi deneyin! ile -Rayrı satırlarda çıktı dizisi öğelerine bayrak.

Python 2,72 bayt

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

Çevrimiçi deneyin!

İfadesi 5>>~x%3için negatif olmayan tamsayılar eşler 1, 2, 5, 1, 2, 5...

Çünkü çalışır 5, 2, 1art arda sağ bitshifts olan 5( 0b101→ 0b10→ 0b1); Onları geriye doğru döndürüyoruz.

Kömür , 36 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

   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 çevrimdışı, 27 26 25 24 23 22 21 bayt

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

Burada dene!

Çevrimiçi bağlantı sondaki sıfırı göstermez, ancak çevrimdışı sürüm Javas BigDecimals'ın iyi olduğunu gösterir.

Açıklama:

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

Çevrimdışı tercümanda çalıştırmak için, SOGLOnlines deposunu indirin , derleyiciye / tercümana gidin, herhangi bir İşleme olan .pdedosyaları açın , ardından işletim sisteminiz için dosya -> dışa aktarın (aksi halde bir İşleme programına argümanlar veremezsiniz: /), ve sonra derlenmiş programı, kodun bulunduğu dosyanın yolunun argümanıyla yürütün. Ardından, stdout'u içerecektir bu .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*18 bayt için neredeyse işe yarıyor ancak sıfır miktar büyüyor, sonuçta 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(boşluklarla değiştirilen yeni satırlar)

Java 8, 109 108 81 80 bayt

Locale fikri için @ OlivierGrégoire'a teşekkürler

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

Çevrimiçi deneyin!

Bash , 38 bayt

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

Varsayılan olarak izin verilen ve bayt gerektirmeyen uygun bir yerel ayar gerektirir .

Çevrimiçi deneyin!

APL (Dyalog) , 30 28 bayt

Tamamlanmış program STDOUT'a boşluğa ayrılmış çıkışlar.

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

Çevrimiçi deneyin!

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

14⍴ döngüsel olarak r , uzunluk 14'e düşer;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

.01 0.01 hazırlamak;
 [0.01,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

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

2⍕ iki ondalık ile biçimlendirme;
 " 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"

⊢ (ayırmak için verim ','den 2)

'\.'⎕R',' PCRE R dönemleri virgülle;
 " 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 bayt

@Giuseppe'den ilham alan:

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

Burada dene!

Ungolfed

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

Pyth , 37 bayt

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

Çevrimiçi deneyin!

Pyth , 37 bayt

Birkaç dakika içinde kısalır.

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

Çevrimiçi deneyin!

JavaScript (ES6), 83 bayt

Bir dizi döndürür.

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

gösteri

let f = 

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

console.log(f())

Özyinelemeli sürüm (ES7), 84 bayt

Sonda boşluk olan bir dize döndürür.

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

gösteri

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 bytes

-2 bytes thanks to @Mr.Xcoder
-1 byte thanks to @EriktheOutgolfer
-2 bytes thanks to @totallyhuman
-2 bytes thanks to @Lynn

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

Try it online!

Retina, 42 bytes

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

Try it online! Explanation: There are fifteen values, with 1, 2 and 5 in each of five places. The first stage inserts five 0s. The second stage repeats them into a square, then changes the trailing diagonal into 1s, then duplicates those lines three times with 2 and 5. The third stage inserts the commas and the last stage removes unnecessary leading zeros.

Charcoal, 37 bytes

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

Try it online! Link is to verbose version.

Yay, compression!

Bash, 88 bytes

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

Try it online!

JavaScript (ES6), 81 bytes

Returns an array.

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

Demo

let f = 

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

console.log(f())

Common Lisp, 95 bytes

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

Try it online!

Husk, 28 bytes

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

Try it online!

Just string manipulation, since Husk is terrible at formatting floating point numbers.

Explanation

ṁ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 bytes

-18 bytes thanks to 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);}

Hardcoded version, by Lynn, 116 bytes

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

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

Try it online!

-9 bytes thanks to Rui Barradas

Outgolfed by AndriusZ

C (gcc), 82 bytes

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

Try it online!

05AB1E, 25 bytes

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

Returns a list of strings.

Try it online.

Explanation:

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и could be •}•15∍ (push compressed 125; enlarge it to size 15: 125125125125125) and '.',: could be „.,`: (push string ".,", pop and push the characters as separated items to the stack) for the same byte-count: Try it online.
Also, N3÷°*т/ can be shortened to N3÷Í°* (where Í subtracts 2), but unfortunately we need the / so all the numbers becomes decimals, whereas with N3÷Í°* most numbers will remain integers.

T-SQL, 104 bytes

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

Line breaks are for readability only.

Annoyingly longer than the trivial PRINT version (90 bytes):

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 bytes

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

Try it online!

Retina, 58 bytes

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

Try it online!

Ruby, 66 62 bytes

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

4 bytes shorter thanks to Lynn!

Try it online!

C# (.NET Core), 107 bytes

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

Run it

JavaScript - 96 bytes

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

And here's a slightly longer (98 characters) functional approach:

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

J, 36 bytes

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

Try it online!

Tcl, 80 bytes

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

Try it online!

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

Try it online!

Still very long, golfing it more later!