26

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.

code-golf sequence kolmogorov-complexity

— Sergiol
quelle

1

Kann es ein abschließendes Leerzeichen geben?

— Dzaima

1

@dzaima: ja. :)

— Sergiol

1

Sind führende Nullen akzeptabel (wie 000,01etc.)?

— Jonathan Allan

8

Die akzeptierte Antwort ist die Antwort, die die Herausforderung gewinnt. Sie können entweder die kürzeste oder gar keine Antwort akzeptieren, aber keine willkürliche.

— Dennis

2

@ KevinCruijssen: Siehe Dennis Antwort als Referenz: codegolf.stackexchange.com/a/141484/29325

— sergiol

27

Pure Bash, 48

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

Probieren Sie es online aus .

— Digitales Trauma
quelle

Gut gespielt! Du hast das Häkchen!

— Sergiol

3

Das Muster ist mir nie aufgefallen ... und ich verwende die Währung seit über 15 Jahren.

— Stephan Bijzitter

@StephanBijzitter viele Währungen funktionieren so.

— NieDzejkob

7

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.

— Justin Mariner
quelle

Gehen Sie für 22 Bytes mehrzeilig .

— Shaggy

7

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.

— Lynn
quelle

6

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

— Neil
quelle

6

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)

— dzaima
quelle

2

Ausgabeformat falsch: "Sie müssen auch das Trailing ,00auf die Integer-Werte setzen." (Ich stelle mir vor, dass dies ,0gegebenenfalls auch das Nachziehen beinhalten soll )

— Jonathan Allan

Sie sollten Ihren Beitrag gemäß der Beobachtung von @JonathanAllan korrigieren. JonathanAllan, danke

— Sergiol

@ JonathanAllan: Hmmmpf, lassen Sie mich Ihren Kommentar mit einem Körnchen Salz nehmen. Der Autor des Beitrags sagt: " Der Online-Link zeigt keine nachgestellten Nullen an, die Offline-Version jedoch, da Javas BigDecimals nett sind. " Ich kann also nicht überprüfen, ob sich das Skript in der Offline-Version gut verhält oder nicht.

— Sergiol

@sergiol Ah, ich habe diesen Text verpasst. Ich frage mich, warum der Online-Dolmetscher in dieser Hinsicht anders implementiert ist - dzaima ...?

— Jonathan Allan

Ich glaube, der Online-Interpreter ist in JavaScript geschrieben, während der Offline- Interpreter in Processing geschrieben ist. Auch Lösungen nicht haben , um prüfbare online zu sein. : P

— totalhuman

6

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!

— Roberto Graham
quelle

Sie können ein Byte speichern, indem Sie zu einem nicht verwendeten Parameter wechseln (Meta-Post dazu) : Versuchen Sie es online

— Justin Mariner

100 Bytes .

— Olivier Grégoire

2

81 Bytes . Funktioniert auf meinem System, da mein Standardgebietsschema be_FR ist. "Arbeit an meinem System" ist gut genug. Ich kann den damit verknüpften Meta-Post nicht finden, aber Sie können ihn verwenden. Um es zu simulieren, müssen Sie nur Locale.setDefault(Locale.FRENCH);im nicht-kompetitiven Teil des TIO.

— Olivier Grégoire

1

@ OlivierGrégoire Hier ist der relevante Meta-Post , und du hast in der Tat Recht, dass es erlaubt ist. Ich habe OP sogar gebeten, dies zu überprüfen, und er hat mich mit Dennis 'Antwort und einem Link zu diesem Metapost verknüpft.

— 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

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!

— Dennis
quelle

Die Ausgabe erfolgt nicht in aufsteigender Reihenfolge!

— Sergiol

Ich habe es gebrochen, als ich von Zeilenumbrüchen zu Leerzeichen gewechselt bin, um ein Byte zu sparen. Jetzt behoben.

— Dennis

5

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"

— Adam
quelle

4

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)

— AndriusZ
quelle

Ich konnte 56 nur mit einer ähnlichen Methode verwalten, nur mit einem t (outer ()) und nicht mit dem rep (). Ich bin mir nicht sicher, ob die Behebung dieses führenden Leerzeichens 4 Byte kosten würde.

— CriminallyVulgar

3

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!

— Mr. Xcoder
quelle

3

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

Code-Snippet anzeigen

let f = 

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

console.log(f())

Erweitern Sie das Snippet

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

Code-Snippet anzeigen

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

console.log(f())

Erweitern Sie das Snippet

— Arnauld
quelle

3

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!

— ovs
quelle

@EriktheOutgolfer vergisst, Leerzeichen zu entfernen

— Mr. Xcoder

Ich habe vergessen anzugeben, welche Art von Trennzeichen zwischen Werten zulässig ist. Keine Sorge, Newline ist akzeptabel.

— Sergiol

2

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.

— Neil
quelle

1

Kohle , 37 Bytes

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

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

Ja, Kompression!

— total menschlich
quelle

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

Probieren Sie es online!

— Justin Mariner
quelle

3

Nach all dieser harten Arbeit 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,00ist die gleiche Länge :(

— Digital Trauma

@DigitalTrauma Aber das macht keinen Spaß: P

— Justin Mariner

1

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

Code-Snippet anzeigen

let f = 

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

console.log(f())

Erweitern Sie das Snippet

— Oki
quelle

1

Common Lisp, 95 Bytes

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

Probieren Sie es online!

— Renzo
quelle

1

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.

— Zgarb
quelle

1

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

— HatsuPointerKun
quelle

Sie sollten ein Online-Beispiel für die Leute hinzufügen, die es laufen sehen. Ich habe es bereits für dich getan

— sergiol

Keine Notwendigkeit für vund 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);}- nur 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");}ist 116 Bytes.

— Lynn

1

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

— Giuseppe
quelle

Ich denke, es gibt keine 1000 €, 2000 € und 5000 €

— AndriusZ

Sie können 5 Bytes sparen, indem Sieprint

— AndriusZ

Durch Mischen Ihrer und meiner Antworten können wir 50 Bytes erreichen -format(c(1,2,5)*10^rep(-2:2,e=3),ns=2,de=",",sc=9)

— AndriusZ

@AndriusZ Ich denke, du brauchst noch eine printAntwort, aber du solltest sie selbst posten. Ich habe gerade die barbarischste Methode angewendet, um die Einstellungen zu ändern, wobei ich formateinige tatsächliche Überlegungen angestellt habe.

— Giuseppe

1

Sie können 8 Bytes einsparen, indem Sie beide optionszu einem kombinieren . options(OutDec=",",scipen=5).

— Rui Barradas

1

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!

— Gastropner
quelle

1

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.

— Kevin Cruijssen
quelle

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

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'

— BradC
quelle

Sie können Ihrer Antwort eine Online-Demo hinzufügen

— sergiol

Und entfernen Sie die Zeilenumbrüche, um mehr Golf zu spielen: rextester.com/ZANC22480

— sergiol

0

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

Probieren Sie es online!

— ovs
quelle

0

Netzhaut , 58 Bytes


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

Probieren Sie es online!

— ovs
quelle

1

Ich habe mit einer Frage an das OP nachgeprüft - die führenden Nullen sind nicht akzeptabel :(

— Jonathan Allan

Sie sollten Ihren Beitrag gemäß der Beobachtung von @JonathanAllan korrigieren. JonathanAllan, danke

— Sergiol

@sergiol repariert es

— ovs

0

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!

— Cristian Lupascu
quelle

-2.upto 2{…}Spart 3 Bytes. '%.2f '.%v*10**mspart ein Byte (Aufruf der %Methode!)

— Lynn

0

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

— Schnarchen
quelle

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}

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(".",","))

— Matt Consto
quelle

0

J , 36 Bytes

echo'.,'charsub 0j2":,1 2 5*/~10^i:2

Probieren Sie es online!

— FrownyFrog
quelle

0

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!

Tcl , 90 Bytes

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

— Sergiol
quelle

Outgolf fehlgeschlagen: tio.run/##BcFBCoAgEAXQq/…

— sergiol

Es belegt den gleichen Byteumfang

— Sergiol

Gleiches Byte-Ausmaß:set i -2;time {lmap c {1 2 5} {puts [regsub \\. [format %.2f [expr $c*1e$i]] ,]};incr i} 5

— Sergiol

Verwenden time, um zu iterieren, anstatt lmapmehr Bytes zu set d -3;time {incr d;lmap c {1 2 5} {puts [regsub \\. [format %.2f $c\e$d] ,]}} 5

— rendern

Euromünzen und Banknoten

Aktualisieren:

Update 2:

Pure Bash, 48

Japt , 23 22 Bytes

Python 2 , 72 Bytes

Kohle , 36 Bytes

SOGLOnline offline, 27 26 25 24 23 22 21 Bytes

Java 8, 109 108 81 80 Bytes

Bash , 38 Bytes

APL (Dyalog) , 30 28 Bytes

R 70 , 50 Bytes

Pyth , 37 Bytes

Pyth , 37 Bytes

JavaScript (ES6), 83 Byte

Demo

Rekursive Version (ES7), 84 Byte

Demo

Python 2 , 80 77 75 73 Bytes

Netzhaut , 42 Bytes

Kohle , 37 Bytes

Bash , 88 Bytes

JavaScript (ES6), 81 Byte

Demo

Common Lisp, 95 Bytes

Schale , 28 Bytes

Erläuterung

C ++, 138 120 Bytes

R , 70 61 Bytes

C (gcc) , 82 Bytes

05AB1E , 25 Bytes

T-SQL, 104 Bytes

Bubblegum , 41 Bytes

Netzhaut , 58 Bytes

Ruby , 66 62 Bytes

C # (.NET Core) , 107 Byte

JavaScript - 96 Bytes

J , 36 Bytes

Tcl , 80 Bytes

Tcl , 90 Bytes