Vì phần lớn các quốc gia sử dụng đồng Euro có ,dấu phân cách thập phân, bạn cũng phải sử dụng nó.

Nhiệm vụ là xuất ra tất cả các giá trị của đồng tiền Euro và ghi chú theo thứ tự tăng dần. Bạn cũng phải đặt dấu vết ,00trên các giá trị số nguyên.

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

Tôi chấp nhận cả đầu ra cho thiết bị xuất chuẩn hoặc một hàm trả về một mảng / danh sách. Nếu đầu ra là thiết bị xuất chuẩn, các dấu tách được chấp nhận giữa các giá trị là: dấu cách, tab hoặc dòng mới.

Sẽ không có câu trả lời được chấp nhận, trừ khi tôi thấy một số tôi thấy rất sáng tạo.

code-golf , vì vậy tôi muốn biết câu trả lời ngắn nhất bằng ngôn ngữ.

Cập nhật:

Số 0không hàng đầu không được chấp nhận. Xin lỗi, tôi nên làm rõ trước.

Cập nhật 2:

Nó cũng được chấp nhận một hàm trả về một chuỗi.

Bash thuần khiết, 48

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

Hãy thử trực tuyến .

Japt , 23 22 byte

-1 byte nhờ @Shaggy

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

Trả về một chuỗi các chuỗi.

Hãy thử trực tuyến! với -Rcờ để xuất các mục mảng trên các dòng riêng biệt.

Python 2 , 72 byte

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

Hãy thử trực tuyến!

Khái niệm 5>>~x%3bản đồ các số nguyên không âm để 1, 2, 5, 1, 2, 5...

Nó hoạt động vì 5, 2, 1là liên tiếp phải bitshifts của 5( 0b101→ 0b10→ 0b1); chúng ta quay vòng qua chúng.

Than , 36 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

   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 ngoại tuyến, 27 26 25 24 23 22 21 byte

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

Hãy thử nó ở đây!

Liên kết trực tuyến không hiển thị các số 0 ở cuối, nhưng phiên bản ngoại tuyến thì như Javas BigDecimals rất hay.

Giải trình:

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

Để chạy trong trình thông dịch ngoại tuyến, tải xuống kho lưu trữ SOGLOnlines , chuyển đến trình biên dịch / trình thông dịch, mở bất kỳ .pdetệp nào có Xử lý , sau đó thực hiện tệp -> xuất cho HĐH của bạn (nếu không bạn không thể đưa ra đối số cho chương trình Xử lý: /), và sau đó thực hiện chương trình được biên dịch với một đối số theo đường dẫn của tệp với mã. Sau đó, thiết bị xuất chuẩn sẽ chứa cái này .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*cho 18 byte gần như hoạt động nhưng số lượng bằng không tăng lên, kết quả là 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(dòng mới được thay thế bằng dấu cách)

Java 8, 109 108 81 80 byte

Cảm ơn @ OlivierGrégoire cho ý tưởng Locale

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

Hãy thử trực tuyến!

Bash , 38 byte

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

Yêu cầu một miền thích hợp, được cho phép theo mặc định và không tốn byte .

Hãy thử trực tuyến!

APL (Dyalog) , 30 28 byte

Hoàn thành chương trình. Đầu ra để phân tách không gian thành STDOUT.

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

Hãy thử trực tuyến!

2 2.5 2 danh sách;
 [2,2.5,2]

14⍴ chu kỳ r eshape đến chiều dài 14;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

.01 trả trước 0,01;
 [0.01,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

×\ nhân tích lũy;
 [0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500]

2⍕ định dạng với hai số thập phân;
 " 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"

⊢ mang lại rằng (để tách ','khỏi 2)

'\.'⎕R',' PCRE R thời gian eplace với dấu phẩy;
 " 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 byte

lấy cảm hứng từ @Giuseppe:

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

Hãy thử nó ở đây!

Bị đánh cắp

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

Bình thường , 37 byte

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

Hãy thử trực tuyến!

Bình thường , 37 byte

Sẽ rút ngắn trong vài phút.

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

Hãy thử trực tuyến!

JavaScript (ES6), 83 byte

Trả về một mảng.

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

Bản giới thiệu

let f = 

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

console.log(f())

Phiên bản đệ quy (ES7), 84 byte

Trả về một chuỗi có dấu cách.

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

Bản giới thiệu

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 byte

-2 byte nhờ @ Mr.Xcoder
-1 byte nhờ @EriktheOutgolfer
-2 byte nhờ @totallyhuman
-2 byte nhờ @Lynn

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

Hãy thử trực tuyến!

Võng mạc , 42 byte

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

Hãy thử trực tuyến! Giải thích: Có mười lăm giá trị, với 1, 2 và 5 ở mỗi năm vị trí. Giai đoạn đầu tiên chèn năm 0. Giai đoạn thứ hai lặp lại chúng thành một hình vuông, sau đó thay đổi đường chéo thành 1s, sau đó nhân đôi các dòng đó ba lần với 2 và 5. Giai đoạn thứ ba chèn dấu phẩy và giai đoạn cuối loại bỏ các số 0 không cần thiết.

Than , 37 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng.

Yay, nén!

Bash , 88 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 81 byte

Trả về một mảng.

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

Bản giới thiệu

let f = 

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

console.log(f())

Lisp thông thường, 95 byte

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

Hãy thử trực tuyến!

Husk , 28 byte

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

Hãy thử trực tuyến!

Chỉ cần thao tác chuỗi, vì Husk rất tệ trong việc định dạng các số dấu phẩy động.

Giải trình

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

-18 byte nhờ 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);}

Phiên bản mã hóa cứng, bởi Lynn, 116 byte

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

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

Hãy thử trực tuyến!

-9 byte nhờ vào Rui Barradas

Bị ruồng bỏ bởi AndriusZ

C (gcc) , 82 byte

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

Hãy thử trực tuyến!

05AB1E , 25 byte

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

Trả về một danh sách các chuỗi.

Hãy thử trực tuyến.

Giải trình:

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иcó thể là •}•15∍(đẩy nén 125; phóng to nó lên kích thước 15 125125125125125:) và '.',:có thể là „.,`:(đẩy chuỗi ".,", bật và đẩy các ký tự dưới dạng các mục riêng biệt vào ngăn xếp) cho cùng một số byte: Hãy thử trực tuyến.
Ngoài ra, N3÷°*т/có thể rút ngắn thành N3÷Í°*( Ítrừ 2), nhưng thật không may, chúng ta cần /như vậy tất cả các số trở thành số thập phân, trong khi với N3÷Í°*hầu hết các số sẽ vẫn là số nguyên.

T-SQL, 104 byte

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

Ngắt dòng chỉ dành cho khả năng đọc.

Khó chịu hơn PRINTphiên bản tầm thường (90 byte):

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'

Bong bóng , 41 byte

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

Hãy thử trực tuyến!

Võng mạc , 58 byte

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

Hãy thử trực tuyến!

Ruby , 66 62 byte

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

4 byte ngắn hơn nhờ Lynn !

Hãy thử trực tuyến!

C # (.NET Core) , 107 byte

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

Chạy nó

JavaScript - 96 byte

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

Và đây là một cách tiếp cận chức năng dài hơn (98 ký tự):

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

J , 36 byte

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

Hãy thử trực tuyến!

Tcl , 80 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Vẫn còn rất lâu, chơi golf nó muộn hơn!