Como la mayoría de las naciones que usan el euro tienen el ,separador decimal, también debe usarlo.

La tarea es generar todos los valores de las monedas y billetes en euros en orden ascendente. También debe colocar el final ,00en los valores enteros.

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

Acepto la salida a stdout o una función que devuelve una matriz / lista. Si la salida es stdout, los separadores aceptables entre valores son: espacio, tabulación o nueva línea.

No habrá respuesta aceptada, a menos que vea a alguien que encuentre muy creativo.

code-golf , así que quiero saber la respuesta más corta por idioma.

Actualizar:

Los 0ceros iniciales no son aceptables. Lo siento, debería dejarlo claro antes.

Actualización 2:

También es aceptable una función que devuelve una cadena.

Pure Bash, 48

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

Pruébalo en línea .

Japt , 23 22 bytes

-1 byte gracias a @Shaggy

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

Devuelve una matriz de cadenas.

Pruébalo en línea! con la -Rbandera para generar elementos de matriz en líneas separadas.

Python 2 , 72 bytes

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

Pruébalo en línea!

La expresión 5>>~x%3asigna los números enteros no negativos a 1, 2, 5, 1, 2, 5...

Funciona porque 5, 2, 1son las sucesivas derecha-bitshifts de 5( 0b101→ 0b10→ 0b1); los recorremos en reversa.

Carbón , 36 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

   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⁾?½

Pruébalo aquí!

El enlace en línea no muestra ceros a la izquierda, pero la versión fuera de línea lo hace como Javas BigDecimals es agradable.

Explicación:

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

Para ejecutar en el intérprete fuera de línea, descargue el repositorio de SOGLOnlines , vaya al compilador / intérprete, abra cualquiera de los .pdearchivos con Processing , luego haga file -> export para su sistema operativo (de lo contrario no puede dar argumentos a un programa Processing: /), y luego ejecute el programa compilado con un argumento en la ruta del archivo con el código. Entonces, stdout contendrá esto .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*para 18 bytes casi funciona pero la cantidad cero crece, lo que da como resultado 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(nuevas líneas reemplazadas por espacios)

Java 8, 109 108 81 80 bytes

Gracias a @ OlivierGrégoire por la idea de Locale

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

Pruébalo en línea!

Bash , 38 bytes

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

Requiere un entorno local apropiado, que está permitido de forma predeterminada y no cuesta bytes .

Pruébalo en línea!

APL (Dyalog) , 30 28 bytes

Programa completo Salidas separadas por espacios a STDOUT.

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

Pruébalo en línea!

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

14⍴ cíclicamente r eshape a la longitud 14;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

.01 anteponer 0.01;
 [0.01,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

×\ multiplicación acumulativa;
 [0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,20,50,100,200,500]

2⍕ formato con dos decimales;
 " 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"

⊢ ceder eso (para separar ','de 2)

'\.'⎕R',' PCRE R períodos EColoque con comas;
 " 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

inspirado en @Giuseppe:

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

Pruébalo aquí!

Sin golf

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

Pruébalo en línea!

Pyth , 37 bytes

Se acortará en unos minutos.

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

Pruébalo en línea!

JavaScript (ES6), 83 bytes

Devuelve una matriz.

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

Manifestación

let f = 

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

console.log(f())

Versión recursiva (ES7), 84 bytes

Devuelve una cadena con un espacio final.

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

Manifestación

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

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

Pruébalo en línea!

Retina , 42 bytes

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

Pruébalo en línea! Explicación: Hay quince valores, con 1, 2 y 5 en cada uno de los cinco lugares. La primera etapa inserta cinco ceros. La segunda etapa los repite en un cuadrado, luego cambia la diagonal final a 1, luego duplica esas líneas tres veces con 2 y 5. La tercera etapa inserta las comas y la última etapa elimina los ceros iniciales innecesarios.

Carbón , 37 bytes

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

Pruébalo en línea! El enlace es a la versión detallada.

Yay, compresión!

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

Pruébalo en línea!

JavaScript (ES6), 81 bytes

Devuelve una matriz.

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

Manifestación

let f = 

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

console.log(f())

Lisp común, 95 bytes

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

Pruébalo en línea!

Casco , 28 bytes

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

Pruébalo en línea!

Solo manipulación de cadenas, ya que Husk es terrible para formatear números de punto flotante.

Explicación

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

Versión codificada, por 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))

Pruébalo en línea!

-9 bytes gracias a Rui Barradas

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

Pruébalo en línea!

05AB1E , 25 bytes

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

Devuelve una lista de cadenas.

Pruébalo en línea.

Explicación:

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иpodría ser •}•15∍(presionar comprimido 125; agrandarlo al tamaño 15:) 125125125125125y '.',:podría ser „.,`:(presionar cadena ".,", hacer estallar y empujar los caracteres como elementos separados a la pila) para el mismo conteo de bytes: Pruébelo en línea.
Además, N3÷°*т/se puede acortar a N3÷Í°*(donde Íresta 2), pero desafortunadamente necesitamos /que todos los números se conviertan en decimales, mientras que con la N3÷Í°*mayoría de los números seguirán siendo enteros.

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

Los saltos de línea son solo para legibilidad.

Molesto más largo que la PRINTversión trivial (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'

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

Pruébalo en línea!

Retina , 58 bytes

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

Pruébalo en línea!

Ruby , 66 62 bytes

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

¡4 bytes más cortos gracias a Lynn !

Pruébalo en línea!

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

Ejecutarlo

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}

Y aquí hay un enfoque funcional un poco más largo (98 caracteres):

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

Pruébalo en línea!

Tcl , 80 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

¡Todavía muy largo, jugando al golf más tarde!