Poiché la maggior parte delle nazioni che usano l'euro ha ,come separatore decimale, è necessario utilizzarlo anche.

Il compito è di produrre tutti i valori delle monete e banconote in Euro in ordine crescente. È inoltre necessario inserire il trailing ,00sui valori interi.

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

Accetto sia l'output su stdout sia una funzione che restituisce un array / elenco. Se l'output è su stdout, i separatori accettabili tra i valori sono: spazio, tab o newline.

Non ci sarà una risposta accettata, a meno che non ne veda qualcuno che trovo molto creativo.

code-golf , quindi voglio sapere la risposta più breve per lingua.

Aggiornare:

Gli 0zeri iniziali non sono accettabili. Scusa, dovrei chiarire prima.

Aggiornamento 2:

È anche accettabile una funzione che restituisce una stringa.

Pure Bash, 48

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

Provalo online .

Japt , 23 22 byte

-1 byte grazie a @Shaggy

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

Restituisce una matrice di stringhe.

Provalo online! con il -Rflag per generare elementi dell'array su righe separate.

Python 2 , 72 byte

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

Provalo online!

L'espressione 5>>~x%3mappa i numeri interi non negativi a 1, 2, 5, 1,2 , 5...

Funziona perché 5, 2, 1sono i successivi destra-bitshifts di 5( 0b101→ 0b10→ 0b1); li attraversiamo all'indietro.

Carbone , 36 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

   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 byte

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

Provalo qui!

Il collegamento online non mostra zero finali, ma la versione offline funziona come Javas BigDecimals è carino.

Spiegazione:

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

PER eseguire nell'interprete offline, scaricare il repository SOGLOnlines , andare al compilatore / interprete, aprire uno dei .pdefile con Elaborazione , quindi eseguire il file -> esportazione per il proprio sistema operativo (altrimenti non è possibile fornire argomenti a un programma di elaborazione: /), e quindi eseguire il programma compilato con un argomento sul percorso del file con il codice. Quindi, stdout conterrà questo .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*per 18 byte quasi funziona ma la quantità zero aumenta, con conseguente 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(nuove righe sostituite con spazi)

Java 8, 109 108 81 80 byte

Grazie a @ OlivierGrégoire per l'idea Locale

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

Provalo online!

Bash , 38 byte

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

Richiede una locale appropriata, che è consentita per impostazione predefinita e non costa byte .

Provalo online!

APL (Dyalog) , 30 28 byte

Programma completo. Output nello spazio separato da STDOUT.

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

Provalo online!

2 2.5 2 la lista;
 [2,2.5,2]

14⍴ ciclicamente r eshape di lunghezza 14;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

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

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

2⍕ formato con due decimali;
 " 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"

⊢ cedere che (per separare ',' da 2)

'\.'⎕R',' PCRE R periodi EPosizionare con virgole;
 " 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

ispirato da @Giuseppe:

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

Provalo qui!

Ungolfed

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

Pyth , 37 byte

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

Provalo online!

Pyth , 37 byte

Si accorcia in pochi minuti.

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

Provalo online!

JavaScript (ES6), 83 byte

Restituisce un array.

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

dimostrazione

let f = 

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

console.log(f())

Versione ricorsiva (ES7), 84 byte

Restituisce una stringa con uno spazio finale.

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

dimostrazione

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 grazie a @ Mr.Xcoder
-1 byte grazie a @EriktheOutgolfer
-2 byte grazie a @totallyhuman
-2 byte grazie a @Lynn

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

Provalo online!

Retina , 42 byte

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

Provalo online! Spiegazione: ci sono quindici valori, con 1, 2 e 5 in ciascuno dei cinque posti. Il primo stadio inserisce cinque 0. Il secondo stadio li ripete in un quadrato, quindi cambia la diagonale finale in 1s, quindi duplica quelle linee tre volte con 2 e 5. Il terzo stadio inserisce le virgole e l'ultimo stadio rimuove gli zeri iniziali non necessari.

Carbone , 37 byte

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

Provalo online!Il collegamento è alla versione dettagliata.

Sì, compressione!

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

Provalo online!

JavaScript (ES6), 81 byte

Restituisce un array.

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

dimostrazione

let f = 

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

console.log(f())

Lisp comune, 95 byte

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

Provalo online!

Buccia , 28 byte

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

Provalo online!

Solo manipolazione di stringhe, poiché Husk è terribile nel formattare numeri in virgola mobile.

Spiegazione

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