Ponieważ większość narodów korzystających z euro ma ,separator dziesiętny, musisz go również używać.

Zadaniem jest wyprowadzenie wszystkich wartości monet i banknotów euro w porządku rosnącym. Musisz również umieścić końcowe ,00wartości całkowite.

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

Akceptuję oba dane wyjściowe na standardowe wyjście lub funkcję zwracającą tablicę / listę. Jeśli wyjście ma być ustawione na standardowe wyjście, dopuszczalne separatory między wartościami to: spacja, tabulator lub znak nowej linii.

Nie będzie żadnej zaakceptowanej odpowiedzi, chyba że zobaczę kogoś, kogo uważam za bardzo kreatywnego.

code-golf , więc chcę znać najkrótszą odpowiedź według języka.

Aktualizacja:

0Zera wiodące są niedopuszczalne. Przepraszam, powinienem wcześniej to wyjaśnić.

Aktualizacja 2:

Dopuszczalna jest również funkcja zwracająca ciąg znaków.

Pure Bash, 48

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

Wypróbuj online .

Japt , 23 22 bajtów

-1 bajt dzięki @Shaggy

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

Zwraca tablicę ciągów.

Wypróbuj online! z -Rflagą do wyświetlania elementów tablicy w osobnych wierszach.

Python 2 , 72 bajty

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

Wypróbuj online!

Wyrażenie 5>>~x%3odwzorowuje nieujemne liczby całkowite do 1, 2, 5, 1, 2, 5...

To działa, ponieważ 5, 2, 1są kolejne prawy-bitshifts z 5( 0b101→ 0b10→ 0b1); przeglądamy je wstecz.

Węgiel drzewny , 36 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

   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 bajtów

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

Wypróbuj tutaj!

Link online nie pokazuje końcowych zer, ale wersja offline robi to, ponieważ Java BigDecimals jest fajna.

Wyjaśnienie:

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

Aby uruchomić interpreter offline, pobierz repozytorium SOGLOnlines , przejdź do kompilatora / interpretera, otwórz dowolny .pdeplik za pomocą Przetwarzania , a następnie wykonaj plik -> eksportuj dla swojego systemu operacyjnego (w przeciwnym razie nie możesz podać argumentów programowi przetwarzającemu: /), a następnie uruchom skompilowany program z argumentem do ścieżki pliku z kodem. Następnie stdout będzie zawierać ten .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*dla 18 bajtów prawie działa, ale liczba zerowa rośnie, co powoduje 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(nowe wiersze zastąpione spacjami)

Java 8, 109 108 81 80 bajtów

Dzięki @ OlivierGrégoire za pomysł Locale

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

Wypróbuj online!

Bash , 38 bajtów

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

Wymaga odpowiedniego ustawienia narodowego, które jest domyślnie dozwolone i nie kosztuje bajtów .

Wypróbuj online!

APL (Dyalog) , 30 28 bajtów

Kompletny program Wyjścia są rozdzielane spacjami do STDOUT.

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

Wypróbuj online!

2 2.5 2 Lista;
 [2,2.5,2]

14⍴ cyklicznie r eshape do długości 14;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

.01 przedkładać 0,01;
 [0.01,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

×\ kumulatywne mnożenie;
 [0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500]

2⍕ format z dwoma miejscami po przecinku;
 " 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"

⊢ otrzymując, że (w celu oddzielenia ','z 2)

'\.'⎕R',' PCRE R okresy EUmieãæ przecinkami;
 " 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 bajtów

zainspirowany @Giuseppe:

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

Wypróbuj tutaj!

Nie golfił

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

Pyth , 37 bajtów

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

Wypróbuj online!

Pyth , 37 bajtów

Skróci się za kilka minut.

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

Wypróbuj online!

JavaScript (ES6), 83 bajty

Zwraca tablicę.

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

Próbny

let f = 

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

console.log(f())

Wersja rekurencyjna (ES7), 84 bajty

Zwraca ciąg ze spacją końcową.

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

Próbny

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 bajtów

-2 bajty dzięki @ Mr.Xcoder
-1 bajtów dzięki @EriktheOutgolfer
-2 bajty dzięki @totallyhuman -2 bajki
dzięki @Lynn

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

Wypróbuj online!

Siatkówka , 42 bajty

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

Wypróbuj online! Objaśnienie: Istnieje piętnaście wartości, z 1, 2 i 5 w każdym z pięciu miejsc. Pierwszy etap wstawia pięć zer. Drugi etap powtarza je w kwadrat, a następnie zmienia ukośną końcową na 1s, a następnie trzykrotnie powiela te linie za pomocą 2 i 5. Trzeci etap wstawia przecinki, a ostatni etap usuwa niepotrzebne zera wiodące.

Węgiel drzewny , 37 bajtów

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

Wypróbuj online! Link jest do pełnej wersji.

Tak, kompresja!

Bash , 88 bajtów

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

Wypróbuj online!

JavaScript (ES6), 81 bajtów

Zwraca tablicę.

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

Próbny

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 bajtów

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

Wypróbuj online!

Łuska , 28 bajtów

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

Wypróbuj online!

Po prostu manipulacja ciągiem, ponieważ Husk jest okropny w formatowaniu liczb zmiennoprzecinkowych.

Wyjaśnienie

ṁ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 bajtów

-18 bajtów dzięki 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);}

Wersja na stałe, Lynn, 116 bajtów

#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 bajtów

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

Wypróbuj online!

-9 bajtów dzięki Rui Barradas

Outgolfed przez AndriusZ

C (gcc) , 82 bajty

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

Wypróbuj online!

05AB1E , 25 bajtów

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

Zwraca listę ciągów.

Wypróbuj online.

Wyjaśnienie:

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иmoże być •}•15∍(push skompresowany 125; powiększyć go do rozmiaru 15 125125125125125:) i '.',:może być „.,`:(push string ".,", pop i popychać znaki jako osobne elementy na stos) dla tej samej liczby bajtów: Wypróbuj online.
Ponadto, N3÷°*т/można skrócić do N3÷Í°*(gdzie Íodejmuje 2), ale niestety musimy /więc wszystkie numery staje dziesiętne, natomiast z N3÷Í°*większości numery pozostaną całkowitymi.

T-SQL, 104 bajty

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

Podziały linii służą wyłącznie do odczytu.

Irytująco dłuższy niż PRINTwersja trywialna (90 bajtów):

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 bajtów

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

Wypróbuj online!

Siatkówka , 58 bajtów

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

Wypróbuj online!

Rubin , 66 62 bajtów

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

4 bajty krótsze dzięki Lynn !

Wypróbuj online!

C # (.NET Core) , 107 bajtów

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

Uruchom

JavaScript - 96 bajtów

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

Oto nieco dłuższe (98 znaków) podejście funkcjonalne:

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

J , 36 bajtów

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

Wypróbuj online!

Tcl , 80 bajtów

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

Wypróbuj online!

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

Wypróbuj online!

Wciąż bardzo długo, grając w golfa później!