Como a maioria dos países que usam o euro tem o ,separador decimal, você também deve usá-lo.

A tarefa é produzir todos os valores das moedas e notas em ordem crescente. Você também deve colocar os valores finais ,00nos valores inteiros.

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

Eu aceito a saída para stdout ou uma função retornando uma matriz / lista. Se a saída for stdout, os separadores aceitáveis ​​entre os valores são: espaço, tabulação ou nova linha.

Não haverá resposta aceita, a menos que eu encontre alguém que eu ache muito criativo.

code-golf , então eu quero saber a resposta mais curta por idioma.

Atualizar:

Leading 0zeros não são aceitáveis. Desculpe, eu deveria deixar claro antes.

Atualização 2:

Também é aceitável uma função retornando uma string.

Pure Bash, 48

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

Experimente online .

Japonês , 23 22 bytes

-1 byte graças a @Shaggy

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

Retorna uma matriz de seqüências de caracteres.

Experimente online! com o -Rsinalizador para gerar itens de matriz em linhas separadas.

Python 2 , 72 bytes

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

Experimente online!

A expressão 5>>~x%3mapeia os inteiros não negativos para 1, 2, 5, 1, 2, 5...

Ele funciona porque 5, 2, 1são os sucessivos-bitshifts direito de 5( 0b101→ 0b10→ 0b1); nós passamos por eles de trás para a frente.

Carvão , 36 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Experimente aqui!

O link online não mostra zeros à direita, mas a versão offline funciona como Javas BigDecimals.

Explicação:

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 executar no interpretador offline, faça o download do repositório SOGLOnlines , acesse o compilador / intérprete, abra qualquer um dos .pdearquivos com Processing e , em seguida, faça o arquivo -> exportar para o seu sistema operacional (caso contrário, você não poderá fornecer argumentos para um programa de processamento: /), e, em seguida, execute o programa compilado com um argumento para o caminho do arquivo com o código. Então, stdout irá conter isso .

2L¼2¹5∙īυ;{⁴Ζ.,ŗP*para 18 bytes quase funciona, mas a quantidade zero aumenta, resultando em 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(novas linhas substituídas por espaços)

Java 8, 109 108 81 80 bytes

Obrigado a @ OlivierGrégoire pela ideia de localidade

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

Experimente online!

Bash , 38 bytes

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

Requer um código de idioma apropriado, que é permitido por padrão e não custa bytes .

Experimente online!

APL (Dyalog) , 30 28 bytes

Programa completo. Saídas para espaço separado para STDOUT.

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

Experimente online!

2 2.5 2 a lista;
 [2,2.5,2]

14⍴ ciclicamente r eshape de comprimento 14;
 [2,2.5,2,2,2.5,2,2,2.5,2,2,2.5,2,2,2.5]

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

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

2⍕ formato com duas casas decimais;
 " 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"

⊢ produzir que (separar ','de 2)

'\.'⎕R',' PCRE R períodos EColoque com vírgulas;
 " 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 por @Giuseppe:

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

Experimente aqui!

Ungolfed

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

Pitão , 37 bytes

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

Experimente online!

Pitão , 37 bytes

Reduzirá em alguns minutos.

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

Experimente online!

JavaScript (ES6), 83 bytes

Retorna uma matriz.

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

Versão recursiva (ES7), 84 bytes

Retorna uma string com um espaço à direita.

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

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

Experimente online!

Retina , 42 bytes

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

Experimente online! Explicação: Existem quinze valores, com 1, 2 e 5 em cada um dos cinco lugares. O primeiro estágio insere cinco 0s. O segundo estágio os repete em um quadrado, depois altera a diagonal final em 1s, depois duplica essas linhas três vezes com 2 e 5. O terceiro estágio insere as vírgulas e o último estágio remove zeros iniciais desnecessários.

Carvão , 37 bytes

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

Experimente online! Link é a versão detalhada.

Yay, compressão!

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

Experimente online!

JavaScript (ES6), 81 bytes

Retorna uma matriz.

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

Lisp comum, 95 bytes

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

Experimente online!

Casca , 28 bytes

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

Experimente online!

Apenas manipulação de strings, pois Husk é péssimo na formatação de números de ponto flutuante.

Explicação

ṁ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 graças ao 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);}

Versão 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 bytes 61

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

Experimente online!

-9 bytes graças 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);}

Experimente online!

05AB1E , 25 bytes

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

Retorna uma lista de strings.

Experimente online.

Explicação:

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иpode ser •}•15∍(pressionado compactado 125; amplie-o para o tamanho 15 125125125125125:) e '.',:pode ser „.,`:(pressionado string ".,", pop e envie os caracteres como itens separados para a pilha) para a mesma contagem de bytes: Experimente on-line.
Além disso, N3÷°*т/pode ser reduzido para N3÷Í°*(onde Ísubtrai 2), mas, infelizmente, precisamos /que todos os números se tornem decimais, enquanto que com a N3÷Í°*maioria dos números permanecerão inteiros.

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

Quebras de linha são apenas para legibilidade.

Irritantemente maior que a PRINTversão 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'

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

Experimente online!

Retina , 58 bytes

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

Experimente online!

Ruby , 66 62 bytes

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

4 bytes mais curtos graças ao Lynn !

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

Executá-lo

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}

E aqui está uma abordagem funcional um pouco mais longa (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

Experimente online!

Tcl , 80 bytes

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

Experimente online!

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

Experimente online!

Ainda muito longo, jogando mais tarde!