Da die meisten Nationen, die den Euro ,verwenden, das Dezimaltrennzeichen verwenden, müssen Sie es auch verwenden.

Die Aufgabe besteht darin, alle Werte der Euro-Münzen und -Noten in aufsteigender Reihenfolge auszugeben. Sie müssen auch das Trailing ,00auf die Integer-Werte setzen.

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

Ich akzeptiere sowohl die Ausgabe auf stdout als auch eine Funktion, die ein Array / eine Liste zurückgibt. Wenn die Ausgabe auf stdout eingestellt ist, sind die zulässigen Trennzeichen zwischen den Werten: Leerzeichen, Tabulator oder Zeilenvorschub.

Es wird keine akzeptierte Antwort geben, es sei denn, ich sehe jemanden, den ich sehr kreativ finde.

Code-Golf , also möchte ich die kürzeste Antwort nach Sprache wissen.

Aktualisieren:

Führende 0Nullen sind nicht zulässig. Entschuldigung, ich sollte es vorher klarstellen.

Update 2:

Es ist auch akzeptabel, dass eine Funktion eine Zeichenfolge zurückgibt.

Pure Bash, 48

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

Probieren Sie es online aus .

Japt , 23 22 Bytes

-1 Byte dank @Shaggy

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

Gibt ein Array von Zeichenfolgen zurück.

Probieren Sie es online! mit dem -RFlag, um Array-Elemente in separaten Zeilen auszugeben.

Python 2 , 72 Bytes

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

Probieren Sie es online!

Der Ausdruck 5>>~x%3bildet die nicht-negativen ganzen Zahlen 1, 2, 5, 1, 2, 5...

Es funktioniert , weil 5, 2, 1sind die aufeinanderfolgenden rechten bitshifts von 5( 0b101→ 0b10→ 0b1); wir fahren rückwärts durch sie hindurch.

Kohle , 36 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

   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 Bytes

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

Probieren Sie es hier aus!

Der Online-Link zeigt keine nachgestellten Nullen an, die Offline-Version hingegen, da Javas BigDecimals nett sind.

Erläuterung:

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

Um den Offline-Interpreter auszuführen , laden Sie das SOGLOnlines-Repository herunter , gehen Sie zu Compiler / Interpreter, öffnen Sie eine der .pdeDateien mit Processing und führen Sie dann den Befehl file -> export für Ihr Betriebssystem aus (andernfalls können Sie einem Processing-Programm keine Argumente geben: /). Führen Sie anschließend das kompilierte Programm mit einem Argument zum Pfad der Datei mit dem Code aus. Dann wird, stdout enthalten diese .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*für 18 Bytes funktioniert fast, aber die Null wächst, was dazu führt, dass 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(Zeilenumbrüche durch Leerzeichen ersetzt werden)

Java 8, 109 108 81 80 Bytes

Vielen Dank an @ OlivierGrégoire für die Locale-Idee

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

Probieren Sie es online!

Bash , 38 Bytes

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

Erfordert ein geeignetes Gebietsschema, das standardmäßig zulässig ist und keine Bytes kostet .

Probieren Sie es online!

APL (Dyalog) , 30 28 Bytes

Komplettes Programm. Ausgänge nach STDOUT durch Leerzeichen getrennt.

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

Probieren Sie es online!

2 2.5 2 Die Liste;
 [2,2.5,2]

14⍴ zyklisch r eshape auf Länge 14;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

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

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

2⍕ Format mit zwei Dezimalstellen;
 " 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"

⊢ ergeben , daß (getrennt ','von 2)

'\.'⎕R',' PCRE R eplace Perioden mit Komma;
 " 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 Bytes

inspiriert von @Giuseppe:

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

Probieren Sie es hier aus!

Ungolfed

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

Pyth , 37 Bytes

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

Probieren Sie es online!

Pyth , 37 Bytes

Verkürzt sich in wenigen Minuten.

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

Probieren Sie es online!

JavaScript (ES6), 83 Byte

Gibt ein Array zurück.

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

Demo

let f = 

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

console.log(f())

Rekursive Version (ES7), 84 Byte

Gibt eine Zeichenfolge mit einem Leerzeichen zurück.

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

Demo

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 dank @ Mr.Xcoder
-1 Bytes dank @EriktheOutgolfer
-2 Bytes dank @totallyhuman
-2 Bytes dank @Lynn

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

Probieren Sie es online!

Netzhaut , 42 Bytes

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

Probieren Sie es online! Erläuterung: Es gibt fünfzehn Werte mit 1, 2 und 5 an jeweils fünf Stellen. Die erste Stufe fügt fünf Nullen ein. Die zweite Stufe wiederholt sie zu einem Quadrat, ändert dann die abschließende Diagonale in 1 und dupliziert diese Zeilen dreimal mit 2 und 5. Die dritte Stufe fügt die Kommas ein und die letzte Stufe entfernt unnötige führende Nullen.

Kohle , 37 Bytes

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

Probieren Sie es online! Link ist zur ausführlichen Version.

Ja, Kompression!

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 . ,;}

Probieren Sie es online!

JavaScript (ES6), 81 Byte

Gibt ein Array zurück.

_=>[...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))))))

Probieren Sie es online!

Schale , 28 Bytes

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

Probieren Sie es online!

Nur String-Manipulation, da Husk das Formatieren von Gleitkommazahlen fürchterlich macht.

Erläuterung

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

Hardcodierte Version von 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))

Probieren Sie es online!

-9 Bytes dank Rui Barradas

Von AndriusZ outgolfed

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

Probieren Sie es online!

05AB1E , 25 Bytes

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

Gibt eine Liste von Zeichenfolgen zurück.

Probieren Sie es online aus.

Erläuterung:

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иwerden könnte •}•15∍(push komprimiert 125; vergrößern zu Größe 15: 125125125125125) und '.',:könnte „.,`:(Push - string „“, Pop und die Zeichen als getrennte Elemente auf den Stapel schieben) für den gleichen Byte-count: Versuchen Sie es online.
Auch N3÷°*т/kann verkürzt N3÷Í°*(wo ÍSubtraktionen 2), aber leider müssen wir das /so alle Zahlen werden Dezimalstellen, während bei den N3÷Í°*meisten Zahlen ganze Zahlen bleiben.

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

Zeilenumbrüche dienen nur der Lesbarkeit.

Ärgerlich länger als die Trivialversion PRINT(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  [email protected]...
00000010: dd2f 788f 8fc2 e192 433c 5c42 e891 7049  ./x.....C<\B..pI
00000020: 11ab 67a6 b8bc 90f5 01                   ..g......

Probieren Sie es online!

Netzhaut , 58 Bytes

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

Probieren Sie es online!

Ruby , 66 62 Bytes

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

4 Bytes kürzer dank Lynn !

Probieren Sie es online!

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

Starte es

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}

Und hier ist ein etwas längerer (98 Zeichen) funktionaler Ansatz:

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

Probieren Sie es online!

Tcl , 80 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Immer noch sehr lange, später mehr Golf spielen!