Notas e moedas de euro

26

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.

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

sergiol
fonte
1
pode haver um espaço à direita?
dzaima 02/09
1
@dzaima: sim. :)
sergiol
1
Os zeros à esquerda são aceitáveis ​​(como 000,01etc.)?
Jonathan Allan
8
A resposta aceita é a resposta que vence o desafio. Você pode aceitar a resposta mais curta ou nenhuma resposta, mas não arbitrária.
Dennis
2
@KevinCruijssen: Veja a resposta de Dennis para referência: codegolf.stackexchange.com/a/141484/29325
sergiol

Respostas:

27

Pure Bash, 48

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

Experimente online .

Trauma Digital
fonte
Bem jogado! Você tem a marca de seleção!
sergiol
3
Eu nunca percebi o padrão ... e eu estive usando a moeda mais de 15 anos ..
Stephan Bijzitter
@StephanBijzitter muitas moedas funcionam assim.
NieDzejkob 04/04
7

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.

Justin Mariner
fonte
Vá várias linhas para 22 bytes .
Shaggy
7

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( 0b1010b100b1); nós passamos por eles de trás para a frente.

Lynn
fonte
6

Carvão , 36 bytes

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

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

   125                                  String `125`
  ×   ⁵                                 Repeated 5 times
 E                                      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
E                                       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
Neil
fonte
6

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)

dzaima
fonte
2
Formato de saída incorreto: "Você também deve colocar os valores finais ,00nos valores inteiros." (I imaginar isso também se destina a incluir a fuga ,0se for caso disso)
Jonathan Allan
Você deve corrigir sua postagem de acordo com a observação de Jonathan Jonathan Allan. JonathanAllan, obrigado
sergiol
@ JonathanAllan: Hmmmpf, deixe-me levar seu comentário com um grão de sal. O autor da postagem diz: " O link online não mostra zeros à direita, mas a versão offline funciona como Javas BigDecimals é bom. ". Portanto, não tenho como verificar se o script se comporta bem ou não na versão offline.
sergiol
@sergiol Ah, eu perdi esse texto. Gostaria de saber por que o intérprete on-line é implementado de maneira diferente a esse respeito - dzaima ...?
Jonathan Allan
Acredito que o intérprete on - line seja escrito em JavaScript, enquanto o intérprete off-line seja escrito em Processing. Além disso, as soluções não precisam ser testadas online. : P
totallyhuman
6

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!

Roberto Graham
fonte
Você pode salvar um byte alternando para um parâmetro não utilizado (meta post sobre isso) : Experimente on-line
Justin Mariner
100 bytes .
Olivier Grégoire
2
81 bytes . Funciona no meu sistema porque meu código de idioma padrão é be_FR. "Trabalhar no meu sistema" é bom o suficiente. Não consigo encontrar o meta-post vinculado a isso, mas você pode usá-lo. Para simular, basta ter Locale.setDefault(Locale.FRENCH);na parte não competitiva do TIO.
Olivier Grégoire
1
@ OlivierGrégoire Aqui está o meta-post relevante e você está certo de que é permitido. Eu até pedi à OP para verificar, e ele me vinculou à resposta de Dennis com um link para este meta post.
Kevin Cruijssen
1
80 bytes:x->{for(double i=.001;i<11;)System.out.printf("%.2f %.2f %.2f ",i*=10,i*2,5*i);}
Nevay
5

APL (Dyalog) , 30 28 bytes

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

'\.'R','2⍕×\.01,142 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"

Adão
fonte
4

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)
AndriusZ
fonte
Eu só conseguia gerenciar 56 usando um método semelhante, apenas com um t (outer ()) ao invés de rep (). No entanto, não tenho certeza se é permitido esse espaço em branco inicial, que custaria 4 bytes para corrigir.
CriminallyVulgar
3

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


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

Arnauld
fonte
3

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!

ovs
fonte
@EriktheOutgolfer esquece de remover espaços
Mr. Xcoder
Esqueci de especificar que tipo de separador entre valores é aceitável. Não se preocupe, a nova linha é aceitável.
sergiol
2

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.

Neil
fonte
1

Carvão , 37 bytes

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

Experimente online! Link é a versão detalhada.

Yay, compressão!

totalmente humano
fonte
1

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!

Justin Mariner
fonte
3
Depois de todo esse trabalho duro, echo 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é do mesmo tamanho :(
Digital Trauma
@DigitalTrauma Mas isso não é divertido: P
Justin Mariner
1

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


Tudo bem eu
fonte
1

Lisp comum, 95 bytes

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

Experimente online!

Renzo
fonte
1

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.
Zgarb
fonte
1

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");}
HatsuPointerKun
fonte
Você deve incluir algum exemplo online para as pessoas que o veem em execução. Eu já fiz isso por você: tio.run/…
sergiol
Não é necessário ve f: 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);}- apenas 120 bytes
MSalters
#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");}tem 116 bytes.
Lynn
1

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

Giuseppe
fonte
Eu acho que não há 1000 €, 2000 € e 5000 €
AndriusZ
Você pode salvar 5 bytes removendoprint
AndriusZ 3/17/17
misturando suas e minhas respostas que podemos alcançar 50 bytes -format(c(1,2,5)*10^rep(-2:2,e=3),ns=2,de=",",sc=9)
AndriusZ
@AndriusZ Acho que você ainda precisa de uma printresposta em torno dessa resposta, mas você deve publicá-la; Eu apenas usei o método mais bárbaro para alterar as configurações, usando formatalgum pensamento real necessário.
Giuseppe
1
Você pode salvar 8 bytes combinando os dois optionsem um. options(OutDec=",",scipen=5).
Rui Barradas
1

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 ","
                   N2i      #  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.

Kevin Cruijssen
fonte
1

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'
BradC
fonte
Você pode anexar à sua resposta uma demonstração on-line: rextester.com/IBKO53221
sergiol
E remova as novas linhas para que seja mais eficiente: rextester.com/ZANC22480
sergiol
0

Retina , 58 bytes


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

Experimente online!

ovs
fonte
1
Eu verifiquei duas vezes com uma pergunta para o OP - os zeros à esquerda não são aceitáveis ​​:(
Jonathan Allan
Você deve corrigir sua postagem de acordo com a observação de Jonathan Jonathan Allan. JonathanAllan, obrigado
sergiol
@sergiol corrigiu
ovs 3/09/17
0

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!

Cristian Lupascu
fonte
-2.upto 2{…}salva 3 bytes. '%.2f '.%v*10**msalva um byte (chamando o %método!)
Lynn
0

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

snorepion
fonte
0

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(".",","))
Matt Consto
fonte
0

Tcl , 80 bytes

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

Experimente online!

Tcl , 90 bytes

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!

sergiol
fonte