I poligoni prendono il nome dal numero di lati che hanno. Un pentagono ha 5 lati, un ottagono ha 8 lati. Ma come si chiamano? Come si chiama un poligono a 248 facce?

Tutti i poligoni hanno il suffisso -gon. Esistono prefissi specifici per ciascun poligono in base al numero di lati. Ecco i prefissi per i numeri inferiori:

3 - tri
4 - tetra
5 - penta
6 - hexa
7 - hepta
8 - octa
9 - nona
10 - deca
11 - undeca
12 - dodeca
13 - triskaideca
14 - tetradeca
15 - pentadeca
16 - hexadeca
17 - heptadeca
18 - octadeca
19 - nonadeca
20 - icosa

I poligoni con 21 a 99 lati hanno un sistema diverso. Prendi il prefisso per la cifra delle decine (che si trova sulla colonna di sinistra), quelle di una (colonna di destra in basso), quindi inserisci un "kai" tra loro per ottenere (tens)kai(ones)gon.

10 - deca        | 1 - hena
20 - icosi       | 2 - di
30 - triaconta   | 3 - tri
40 - tetraconta  | 4 - tetra
50 - pentaconta  | 5 - penta
60 - hexaconta   | 6 - hexa
70 - heptaconta  | 7 - hepta
80 - octaconta   | 8 - octa
90 - nonaconta   | 9 - nona

I poligoni a 3 cifre sono denominati in modo simile. Un poligono a 100 facce è chiamato un ectogon. Prendi le centinaia di cifre, trovale sulla colonna per una cifra, quindi attacca un "hecta" alla sua destra. Ora il numero fuori le decine e quelli come sopra: (hundreds)hecta(tens)kai(ones)gon. Se la cifra delle centinaia di posti è 1, non mettere il prefisso dietro "hecta"; se quello posto è 0, ometti la sezione (uni).

Quindi, dato un numero intero (3 <= n <= 999), restituisce il nome di un poligono n-side. n-gonnon è una risposta valida: P

Come per tutto il codice golf, vince il codice più corto.

C, 401 , 391

Mettiamo qualcosa là fuori in modo che ci sia almeno una risposta per riferimento :-)

char*s[]={"","hena","di","tri","tetra","penta","hexa","hepta","octa","nona","un","do","triskai","deca","icosi","tria","conta","kai","icosa","hecto","hecta","gon\n"};
p(i){printf(s[i]);}
t;n(i){
    if(i<10)
        p(i);   // ones
    else if(i<20){
        i-=10; 
        p(i+(i&&i<4)*9); // teens
        p(13); // "deca"
    }else if(i==20)
        p(18); // "icosa"
    else if(i==100)
        p(19); // "hecto"
    else{
        t=i/100;
        p(t>1?t:0); // hundreds
        p(t?20:0);  // "hecta"
        i%=100;
        t=i/10;
        p(t+(t&&t<4)*12); // tens
        p(t>2?16:0);      // "conta"
        i%=10;
        p(i?17:0); // "kai"
        p(i);      // ones
    }
    p(21); // "gon\n"
}

Prova con:

main(){
    for(int i=3;i<=999;i++){
        printf("%3d: ",i);n(i);
    }
}

Sottoinsieme dell'output:

  3: trigon
  4: tetragon
  5: pentagon
  6: hexagon
  7: heptagon
  8: octagon
  9: nonagon
 10: decagon
 11: undecagon
 12: dodecagon
 13: triskaidecagon
 14: tetradecagon
 15: pentadecagon
 16: hexadecagon
 17: heptadecagon
 18: octadecagon
 19: nonadecagon
 20: icosagon
 21: icosikaihenagon
 22: icosikaidigon
 23: icosikaitrigon
...
 99: nonacontakainonagon
100: hectogon
101: hectakaihenagon
102: hectakaidigon
103: hectakaitrigon
104: hectakaitetragon
105: hectakaipentagon
106: hectakaihexagon
107: hectakaiheptagon
108: hectakaioctagon
109: hectakainonagon
110: hectadecagon
111: hectadecakaihenagon
...
997: nonahectanonacontakaiheptagon
998: nonahectanonacontakaioctagon
999: nonahectanonacontakainonagon

JavaScript - 405 386

Versione 1: (405 caratteri)

i=prompt(),o='0hena0di0tri0tetra0penta0hexa0hepta0octa0nona'.split(0),d='0W0icosi0triaQ0tetraQ0pentaQ0hexaQ0heptaQ0octaQ0nonaQ'.split(0),t='W0unW0doW0triskaiW0tetraW0pentaW0hexaW0heptaW0octaW0nonaW0icosa'.split(0),x=('000'+i).substr(-3).split('');alert((i<10?o[i]:i<21?t[i-10]:i==100?'hecto':(i<100?'':i<200?'hecta':o[x[0]]+'hecta')+d[x[1]]+'kai'+o[x[2]]).replace(/Q/g,'conta').replace(/W/g,'deca')+'gon')

Versione 2: (386 caratteri)

i=prompt(),p='0tetra0penta0hexa0hepta0octa0nona',o='0hena0di0tri'+p,t=('W0unW0doW0triskai'+p.replace(/0/g,'W0')+'W0icosa').split(0),x=('000'+i).substr(-3).split(''),o=o.split(0);alert((i<10?o[i]:i<21?t[i-10]:i==100?'hecto':(i<100?'':i<200?'hecta':o[x[0]]+'hecta')+('0W0icosi0tria'+p.replace(/0/g,'Q0')+'Q').split(0)[x[1]]+'kai'+o[x[2]]).replace(/Q/g,'conta').replace(/W/g,'deca')+'gon')

Esempio di output:

3: trigon
4: tetragon
5: pentagon
6: hexagon
7: heptagon
8: octagon
9: nonagon
10: decagon
11: undecagon
12: dodecagon
13: triskaidecagon
14: tetradecagon
15: pentadecagon
16: hexadecagon
17: heptadecagon
18: octadecagon
19: nonadecagon
20: icosagon
21: icosikaihenagon
22: icosikaidigon
23: icosikaitrigon
99: nonacontakainonagon
...
100: hectogon
101: hectakaihenagon
102: hectakaidigon
103: hectakaitrigon
104: hectakaitetragon
105: hectakaipentagon
106: hectakaihexagon
107: hectakaiheptagon
108: hectakaioctagon
109: hectakainonagon
110: hectadecakaigon
111: hectadecakaihenagon
...
997: nonahectanonacontakaiheptagon
998: nonahectanonacontakaioctagon
999: nonahectanonacontakainonagon 

Cobra - 370 byte

Questa è attualmente una funzione, ma se ciò non è consentito, la cambierò.

def f(x) as String
    o='. hena di tri tetra penta hexa hepta octa nona'.split
    o[0],t,h,d='',['','deca','icosci','triconta'],['','hecta','dihecta','trihecta'],['undeca','dodeca','triskaideca']
    for z in 4:10,t,h,d=t+[o[z]+'conta'],h+[o[z]+'hecta'],d+[o[z]+'deca']
    for z in 10,t[z]+='kai'
    return if(x-100,h[x//100]+if(10<x<20,d[x-11],t[x%100//10]+o[x%10]),'hecto')+'gon'

E per qualche ragione, l'evidenziatore di cobra si è //impostato come commento, il che è sbagliato.