Es war eine Herausforderung , eine Zahl in ihre englische Zahl umzuwandeln , aber das war zu einfach. Bei einer Zahl von 0 bis 100 müssen Sie die entsprechende Zahl auf Französisch ausgeben. Das französische Zahlensystem hat eine komplexere Logik als das englische:

Nummer Ziffer
---------------
 0 zéro (Akzent beachten)
 1 un
 2 deux
 3 trois
 4 Quatre
 5 cinq
 6 sechs
 7. September
 8 huit
 9 neuf
10 dix
11 onze
12 verdoppeln
13 treize
14 quatorze
15 quinze
16 ergreifen
17 dix-sept (wörtlich zehn sieben)
18 Dix-Huit
19 Dix-Neuf
20 vingt
21 vingt et un (keine Bindestriche)
22 vingt-deux
...
30 trente
...
40 Quarantäne
...
50 cinquante
...
60 Soixante
...
70 Soixante-Dix (buchstäblich zehnundsechzig)
71 soixante et onze
...
80 Quatre-Vingts (beachten Sie die s; buchstäblich vier zwanziger Jahre)
81 quatre-vingt-un (beachten Sie die Bindestriche)
...
90 Quatre-Vingt-Dix
91 quatre-vingt-onze
...
99 quatre-vingt-dix-neuf (4 * 20 + 10 + 9)
100 cent

Eine vollständige Liste finden Sie unter http://quizlet.com/996950/ ( http://www.webcitation.org/6RNppaJx0 ).

Weitere Regeln / Erläuterungen

• Zwischen den Wörtern wird immer ein Bindestrich stehen, AUSSER wenn die Zahl auf 1 endet.
• Wenn die Zahl auf 1 endet, wird das Wort et (Bedeutung und ) vor dem un oder onze hinzugefügt . (31 = trente et un)
• 81 und 91 sind jedoch genauso formatiert wie die anderen Zahlen. (81 = quatre-vingt-un)
• Bei 60 schaltet das System von der Basis 10 auf die Basis 20 um.
• Es gibt einige kleinere Unstimmigkeiten im Internet. Beziehen Sie sich bei Fragen auf die oben verlinkte Liste.
• Lücken, die standardmäßig verboten sind, sind nicht erlaubt.
• Die Verwendung einer externen Quelle wie einer Website sowie von Bibliotheken, APIs, Funktionen oder Ähnlichem, die Zahlen in Ziffern umwandeln oder ins Französische übersetzen, ist nicht zulässig.
• Das ist Code-Golf , also gewinnt die Antwort mit den wenigsten Bytes.
• Wenn verfügbar, verlinken Sie bitte zu einem Online-Compiler, um Ihren Code einfach testen zu können.

Eingang

• Die Eingabe erfolgt nach Maßgabe Ihrer Sprache. (STDIN, Befehlszeile usw.)
• Die Eingabe ist eine einzelne Zeichenfolge, die aus einer ganzen Zahl zwischen einschließlich 0 und 100 besteht (führende Nullen optional).
• Sie können davon ausgehen, dass die Eingabe immer wohlgeformt ist.

Ausgabe

• Das Ergebnis wird in der für Ihre Sprache am besten geeigneten Methode ausgegeben. (STDOUT, Dialogfeld usw.)
• Groß- / Kleinschreibung spielt in der Ausgabe keine Rolle.

Beispiele

Testen Sie Ihren Code anhand folgender Kriterien:

Input-Output
-------------
0 zéro
18 Dix-Huit
51 cinquante et un
80 Quatre-Vingts
91 quatre-vingt-onze
99 quatre-vingt-dix-neuf

JavaScript (ES6) 318 321

Bearbeiten Sie Bugfixes (Verwalten führender Nullen) und spielen Sie mehr Golf

Gutschrift für den Kamelfalltrick @ Core1024

Mit Ein- / Ausgabe über Popup

alert((n=prompt(),w='ZéroUnDeuxTroisQuatreCinqSixSeptHuitNeufDixOnzeDouzeTreizeQuatorzeQuinzeSeizeDix-septDix-huitDix-neufVingtTrenteQuaranteCinquanteSoixante'.match(/[A-Z][^A-Z]+/g),
u=n%10,s=u-1|n>80?d='-':' et ',n>99?'Cent':n<21?w[n|0]:n<70?w[18+n/10|0]+(u?s+w[u]:''):(n<80?w[24]:w[4]+d+w[20])+(n-80?s+w[n%20]:'s')))

Als testbare Funktion

F=n=>(
  w='ZéroUnDeuxTroisQuatreCinqSixSeptHuitNeufDixOnzeDouzeTreizeQuatorzeQuinzeSeizeDix-septDix-huitDix-neufVingtTrenteQuaranteCinquanteSoixante'
  .match(/[A-Z][^A-Z]+/g),
  u=n%10,s=u-1|n>80?d='-':' et ',
  n>99?'Cent':
  n<21?w[n|0]:
  n<70?w[18+n/10|0]+(u?s+w[u]:''):
  (n<80?w[24]:w[4]+d+w[20])+(n-80?s+w[n%20]:'s')
)

So testen Sie in der FireFox-Konsole oder in FireBug

for (i = 0; i < 100; console.log(r),i+= 10) 
  for (j=0, r=''; j < 10; j++)
    r+=(i+j)+':'+F(i+j+'')+", "; // specific: input is a string
F('100')

Ausgang testen

0: Zéro, 1: Un, 2: Deux, 3: Trois, 4: Quatre, 5: Cinq, 6: Six, 7: Sept, 8: Huit, 9: Neuf,
10: Dix, 11: Onze, 12: Douze, 13: Treize, 14: Quatorze, 15: Quinze, 16: Seize, 17: Dix-Sept, 18: Dix-Huit, 19: Dix-Neuf,
20: Vingt, 21: Vingt et Un, 22: Vingt-Deux, 23: Vingt-Trois, 24: Vingt-Quatre, 25: Vingt-Cinq, 26: Vingt-Six, 27: Vingt-Sept, 28: Vingt- Huit, 29: Vingt-Neuf,
30: Trente, 31: Trente et Un, 32: Trente-Deux, 33: Trente-Trois, 34: Trente-Quatre, 35: Trente-Cinq, 36: Trente-Six, 37: Trente-Sept, 38: Trente- Huit, 39: Trente-Neuf,
40: Quarante, 41: Quarante et Un, 42: Quarante-Deux, 43: Quarante-Trois, 44: Quarante-Quatre, 45: Quarante-Cinq, 46: Quarante-Six, 47: Quarante-Sept, 48: Quarante- Huit, 49: Quarante-Neuf,
50: Cinquante, 51: Cinquante et Un, 52: Cinquante-Deux, 53: Cinquante-Trois, 54: Cinquante-Quatre, 55: Cinquante-Cinq, 56: Cinquante-Six, 57: Cinquante-Sept, 58: Cinquante- Huit, 59: Cinquante-Neuf,
60: Soixante, 61: Soixante et Un, 62: Soixante-Deux, 63: Soixante-Trois, 64: Soixante-Quatre, 65: Soixante-Cinq, 66: Soixante-Six, 67: Soixante-Sept, 68: Soixante- Huit, 69: Soixante-Neuf,
70: Soixante-Dix, 71: Soixante et Onze, 72: Soixante-Douze, 73: Soixante-Treize, 74: Soixante-Quatorze, 75: Soixante-Quinze, 76: Soixante-Seize, 77: Soixante-Dix-Sept, 78: Soixante-Dix-Huit, 79: Soixante-Dix-Neuf,
80: Quatre-Vingts, 81: Quatre-Vingt-Un, 82: Quatre-Vingt-Deux, 83: Quatre-Vingt-Trois, 84: Quatre-Vingt-Quatre, 85: Quatre-Vingt-Cinq, 86: Quatre- Vingt-Six, 87: Quatre-Vingt-Sept, 88: Quatre-Vingt-Huit, 89: Quatre-Vingt-Neuf,
90: Quatre-Vingt-Dix, 91: Quatre-Vingt-Onze, 92: Quatre-Vingt-Douze, 93: Quatre-Vingt-Treize, 94: Quatre-Vingt-Quatorze, 95: Quatre-Vingt-Quinze, 96: Quatre-Vingt-Seize, 97: Quatre-Vingt-Dix-Sept, 98: Quatre-Vingt-Dix-Huit, 99: Quatre-Vingt-Dix-Neuf, 
"Cent"

Haskell, 390 Bytes

b=(words"zéro un deux trois quatre cinq six sept huit neuf dix onze douze treize quatorze quinze seize vingt trente quarante cinquante soixante"!!)
a!b=a++"-"++b
f 0=b 0
f 71=f 60++" et onze"
f 80=f 4!b 17++"s"
f 100="cent"
f x|x<17=b x|x<20=b 10!b(x-10)|x>80=b 4!b 17!f(x-80)|m==1=f(x-1)++" et un"|x>60=f 60!f(x-60)|m==0=b(15+div x 10)|1<2=f(x-m)!f m where m=mod x 10
main=interact$f.read

Ungolfed

base :: Int -> String
--              0    1  2    3     4      5    6   7    8    9    10  11   12     13     14       15     16    17    18     19       20        21      
base i = words "zéro un deux trois quatre cinq six sept huit neuf dix onze douze  treize quatorze quinze seize vingt trente quarante cinquante soixante" !! i

hyphen :: String -> String -> String
a `hyphen` b = a ++ "-" ++ b

say :: Int -> String
say 0 = base 0
say 71 = say 60 ++ " et onze"
say 80 = say 4 `hyphen` base 17 ++ "s"
say 100 = "cent"
say x
  | x < 17 = base x
  | x < 20 = base 10 `hyphen` base (x - 10)
  | x > 80 = base 4 `hyphen` base 17 `hyphen` say (x - 80)
  | m == 1 = say (x - 1) ++ " et un"
  | x > 60 = say 60 `hyphen` say (x - 60)
  | m == 0 = base (div x 10 + 15)
  | otherwise = say (x - m) `hyphen` say m
  where m = mod x 10

main = putStr.say.read=<<getLine

Funktionale Programmiersprachen sind für diesen Job durchaus geeignet.

Ruby, 333 Bytes

l=['']+%w{un deux trois quatre cinq six sept huit neuf dix onze douze treize quatorze quinze seize}
d=%w{vingt trente quarante cinquante soixante _ quatre-vingt}+['']*2
n=gets.to_i
v=n%20
t=n%10
puts n<1?'zéro':n>99?'cent':d[(n<70?n:n-v)/10-2]+(n<21||t<1&&n<61?'':v<1??s:t==1&&n<80?' et ':?-)+(n>60||n<20?v<17?l[v]:'dix-'+l[t]:l[t])

Meist sind es nur zwei Nachschlagetabellen und eine Reihe von ternären Operatoren, die alle seltsamen Regeln codieren und Ihnen sagen, welche Nachschlagetabelle wann verwendet werden soll. Lass es mich wissen, wenn du mehr wissen willst. ;)

Python - 344 (348) (380) (445) (537) Bytes

Dank an grc, Ray und isaacg für ihre Hilfe im Golfprozess.

Der Code besteht aus der anfänglichen Wörterbuchdefinition und einem Listenverständnis, das die Lücken mit der Verknüpfung der Wörterbuchelemente ausfüllt.

Sie können den Code online unter repl.it überprüfen

r=range
def f(a):b=a/60*10+10;d[a]=d[a-a%b]+(' et ','-')[a%10!=1or a>80]+d[a%b]
d=dict(zip(r(17)+r(20,70,10)+[80,100],'zéro un deux trois quatre cinq six sept huit neuf dix onze douze treize quatorze quinze seize vingt trente quarante cinquante soixante quatre-vingt cent'.split()))
[f(v)for v in r(100)if(v in d)<1]
d[80]+='s'
print d[input()]

Meine letzten Versuche, diesen Code zu spielen, bestanden darin, auf den Generierungsprozess zu verzichten und mit dieser Reduzierung die Funktion zu verfeinern, um nur die angeforderte Nummer vor Ort zu generieren. Da die Zahlen der 60er und 80er Jahre jedoch nicht berechnete Elemente benötigen, bestand der Kampf darin, eine solche Funktion zu erstellen und dabei den Code zu verringern.

Python - 392 Bytes

Es hat eine Liste mit Basisnummern, aus denen die anderen Nummern generiert werden. Der größte Teil der Generierungslogik befindet sich im Listenverständnis in Zeile 2 und verwendet die Listenindizierung für Bedingungen. Sobald die Liste erstellt ist, schlägt sie die eingegebene Nummer nach und druckt sie aus.

Edit: Ab 426 Bytes mit grcs Spitze gekürzt.

a='_un_deux_trois_quatre_cinq_six_sept_huit_neuf_dix_onze_douze_treize_quatorze_quinze_seize_dix-sept_dix-huit_dix-neut'.split('_')
a+=[[['vingt','trente'],['quarante','cinquante'],['soixante']*2,[a[4]+'-vingt']*2][b][c>9]+['','-',' et '][(c%[10,20][b>1]>0)+(c%10==1)*(b<3)]+a[c%[10,20][b>1]]for b in[0,1,2,3]for c in range(20)]
a[0]='zéro'
a[80]+='s'
a+=['cent']
print(a[int(input())])

Python 3 (503 Byte)

Komprimieren Sie die Tabelle mit bzip2 und verwenden Sie dann die ASCII85-Codierung, um das Ergebnis zu speichern. Die Tabelle ist:

zéro
un
deux
trois
quatre
cinq
...
cent

Sehr naive Methode, aber so schlimm ist es nicht.

Golf gespielt

import bz2,base64 as B
print(bz2.decompress(B.a85decode('6<\\%_0gSqh;d"=$\\VU:fOjTBn&3p:MiVu^S+:%s4!Q6o8\\8%r<Bp,5\\LT&Q+19!OmJC@3n\'bD<]UHekq<8OP<;]9BZ,;>836X4<[@KJ,)FsD^8j9Q=]O]&/8\'rjSK&0Sh0W[ru0E0!!M-tL69NZF6N\'Lc#$Q=?S_P0+uEZP"[H;%Ucch??nYC76\'k<)isZIBqqOKi(,IHp""^8d/EqRpc_I<IRj[\'4KB`/."%5,"pjr&27q+&t.6J+ik=Jdd2A)j]\'jt5ts0>:sr9.@E>V0F9L?9r&pX\'E.NUP:r&?>\'*(gKmd;/1QkUb*1&JhfWiE7Kl,P,o1go+.3O&l))Y,$/PO)%"al^4H2,n-l\\PuM!W1rBB9t.,U>DhAs83burMn(%%-qHG<gr+^')).decode().split('\n')[int(input())])

Ungolfed

import bz2, base64
s = '6<\\%_0gSqh;d"=$\\VU:fOjTBn&3p:MiVu^S+:%s4!Q6o8\\8%r<Bp,5\\LT&Q+19!OmJC@3n\'bD<]UHekq<8OP<;]9BZ,;>836X4<[@KJ,)FsD^8j9Q=]O]&/8\'rjSK&0Sh0W[ru0E0!!M-tL69NZF6N\'Lc#$Q=?S_P0+uEZP"[H;%Ucch??nYC76\'k<)isZIBqqOKi(,IHp""^8d/EqRpc_I<IRj[\'4KB`/."%5,"pjr&27q+&t.6J+ik=Jdd2A)j]\'jt5ts0>:sr9.@E>V0F9L?9r&pX\'E.NUP:r&?>\'*(gKmd;/1QkUb*1&JhfWiE7Kl,P,o1go+.3O&l))Y,$/PO)%"al^4H2,n-l\\PuM!W1rBB9t.,U>DhAs83burMn(%%-qHG<gr+^'
table = bz2.decompress(base64.a85decode(s)).decode().split('\n')
num = int(input())
print(table[num])

Bonus

Kannst du das Wort "Vim" in der komprimierten Zeichenfolge finden?

Bash, 456 440 421 408

Nimmt eine gültige Eingabe an (Ganzzahl von 0 bis 100 mit einer beliebigen Anzahl führender Nullen).

v=`sed 's/0*//'<<<$1`
f=('' dix vingt trente quarante cinquante soixante soixante-dix quatre-vingts quatre-vingt-dix)
s=('' ' et un' -deux -trois -quatre -cinq -six -sept -huit -neuf)
o=${f[${v: -2:1}]}${s[${v: -1:1}]}
[ "${o:0:1}" = \  ]&&o=un
((v>99))&&o=cent
sed 's/^-//
s/s-/-/
s/s et /-/
s/dix et un/onze/
s/di.*ux/douze/
s/d.*s$/treize/
s/d.*re/quatorze/
s/d.*q/quinze/
s/di.*ix/seize/'<<<${o:-zéro}

JavaScript 459 (kein Kamelgehäuse)

@ edc65 kann dir das nicht nehmen ...;)

A="0un0deux0trois0quatre0cinq0six0sept0huit0neuf0dix0onze0douze0treize0quatorze0quinze0seize0dix-sept0dix-huit0dix-neuf".split(0);S="soixante";Q=A[4]+"-vingt";T=10;V=20;N=59;for(b=5;1<b--;)for(c=V;c--;)X=b*V+c,A[X]=[,["vingt","trente"],["quarante","cinquante"],[S,S],[Q,Q]][b][c/T|0]+(X%T?X>N?X%V==T?"-dix":"":"":"")+(1>X%T?"":(1==X%(X>N?V:T)|71==X)&81!=X?" et ":"-")+(X>N&X%V==T?"-dix":A[c%(X>N?V:T)]);A[0]="zéro";A[80]+="s";A[100]="cent";alert(A[prompt()])