Noms d'éléments supérieurs à 118


46

Dans leur insupportable sagesse, l' IUPAC a créé un nom d'élément systématique pour tout élément nouvellement créé. C'est le nom temporaire d'un élément jusqu'à ce qu'ils se décident enfin du nom réel. Cela fonctionne comme suit: chaque préfixe d'un numéro d'élément se voit attribuer un préfixe en fonction de sa valeur. Les préfixes sont concaténés avec "ium" à la fin. Lorsque cela est fait et si vous obtenez double i (ii) ou triple n (nnn), remplacez-les par simples i et doubles n. Le symbole de l'élément est la première lettre de chaque préfixe utilisé, concaténé et en majuscule. Les préfixes utilisés sont ci-dessous.

0 nil       5 pent
1 un        6 hex
2 bi        7 sept
3 tri       8 oct
4 quad      9 enn

Donc, pour ce golf, votre code doit générer à la fois le nom de l'élément et son symbole pour un entier positif donné. Donc, si votre code a été donné 137, il devrait imprimer sur stdout ou renvoyer les deux untriseptiumet Uts. Il devrait être valide d'au moins 118 à 558 . Toute valeur supérieure est valable si elle n'augmente pas la longueur de votre code.

Exemple Python montrant la méthode:

def elename(n):
    '''Return name and symbol of new element for given element number.'''
    prefixes=['nil','un','bi','tri','quad','pent','hex','sept','oct','enn']
    nmeFixes, symFixes = [], []

    while n:  # each digit of element number is assigned a prefix
        n, i = divmod(n, 10)
        pf = prefixes[i]

        symFixes.append(pf[0])  # symbol uses only first letter of prefix
        nmeFixes.append(pf)

    # loop assembled prefixes in reverse order
    nmeFixes.reverse()
    symFixes.reverse()

    nmeFixes.append('ium')  # suffix
    name = ''.join(nmeFixes)
    symb = ''.join(symFixes).capitalize()

    # apply rule about too many n's or i's
    name = name.replace('nnn','nn')  # can happen with -90-
    name = name.replace('ii','i')  # -2ium or -3ium

    return name, symb

Eric Towers gagne avec des octets de cadmium!


34
Je vais commencer à appeler Boron par son nom systématique d'élément IUPAC: "Pentium"
Michael


1
Faut-il avoir le bon cas?
lirtosiast

6
@BetaDecay Mais ce "cinquième élément" prend-il en charge MultiPass ?
Damian Yerrick

Réponses:


22

Mathematica 10.1, indium (49) cadmium (48)

Cette solution utilise une bibliothèque intégrée de propriétés d'élément, y compris les noms et les abréviations IUPAC. (Je n’ai pas vu cela comme une technique à éviter en Golf. Cela semble être encouragé. Mais c’est peut-être à la limite de ce qui est acceptable - Mathematica implémente cette bibliothèque (et beaucoup d’autres) en téléchargeant des données depuis Les serveurs de Wolfram la première fois que vous l'utilisez (et je suppose que vérifie les mises à jour à l'occasion).)

f=ElementData@@@{{#,"Abbreviation"},{#,"Name"}}&
(* 
Improved by @user5254 from 
f[n_]:=ElementData[n,#]&/@{"Abbreviation","Name"} 
*)

f[48]
(* {"Cd", "cadmium"} *)

f[118]
(* {"Uuo", "ununoctium"} *)

f[122]
(* {"Ubb", "unbibium"} *)

f[190]
(* {"Uen", "unennilium"} *)

f[558]
(* {"Ppo", "pentpentoctium"} *)

f[10^100-1]
(* {"Eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "ennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennium"} *)

Comment cela se compare-t-il à l'utilisation d'éléments.py ou periodictable.py en Python?

Edit: Des mois plus tard: J'ai remarqué que j'avais écrit l'abréviation pour 122. J'ai relu le code et vérifié que j'avais commis cette erreur, pas Mathematica.


9
En écrivant ce défi, je me suis dit: "Devrais-je empêcher les fonctions intégrées? Non, il est peu probable que cela soit intégré à une langue. Attendez, Mathematica l’a peut-être." Mais je ne savais pas comment vérifier cela et je l’oubliai rapidement.
Statut

7
Saintes parenthèses, Batman! Ce paragraphe ressemble à quelque chose que j'aurais pu écrire (moi aussi, je suis coupable d'utiliser des parenthèses en plus pour tenter d'atténuer ma verbosité - elles deviennent généralement comme ça, cependant).
Cole

1
Vous pouvez enregistrer un octet en utilisant appliquer interne et faire flui - même une fonction pure: f=ElementData@@@{{#,"Abbreviation"},{#,"Name"}}&.

Ce code ne deviendra-t-il pas invalide pour 118 si l'élément en question acquiert un nom officiel?

1
@ ais523: Selon la spécification "Donc, pour ce golf, votre code doit générer à la fois le nom de l'élément et son symbole pour un entier positif donné." Si l'élément porte un nom ou un symbole, ce nom ou ce symbole doit être indiqué. Par votre métrique, alors, toute soumission sur cette page ne sera pas conforme à la spécification si un élément avec un numéro atomique> = 118 obtient un symbole ou un nom systématique.
Eric Towers

27

Python 3, Unhexseptium (167) octets

h=x='';r=str.replace
for i in input():s=r('nubtqphsoeinirueeecnl  ianxptn    dt t'[int(i)::10],' ','');h+=s;x+=s[0]
print(r(r(h+'ium\n','ii','i'),'nnn','nn')+x.title())

Ce sont les résultats lorsque le programme est exécuté sur chaque nombre de 1 à 999 (inclus)


30
Votre en-tête me donne maintenant envie que tout le monde liste le nombre d'octets de cette façon.
Statut

4
@Status Entendre, entendre. Cela va rendre les gars de Pyth très tristes ... :)
beaker

1
@beaker Je suis déçu que la photo de votre profil ne soit pas Beaker ;)
Beta Decay

4
@BetaDecay Fait.
Bécher

6
@Status: si quelqu'un réussit à le faire en moins de 112 octets, il peut avoir un nom d'élément classique dans le titre :) Comme rutherfordium . Ou d' or .
vsz

15

Pip , radium actinium thorium (86)

(N'inspirez pas cette entrée, cela vous donnera un cancer du poumon.)

P(aR,tY"nil un bi tri quad pent hex sept oct enn"^s)."ium"R`ii|nnn`_@>1Yy@_@0MaUC:y@0y

Prend le numéro d'élément en tant qu'argument de ligne de commande et affiche le nom et l'abréviation sur des lignes séparées.

Explication (un peu non golfée):

Y"nil un bi tri quad pent hex sept oct enn"^s  Build list of prefixes & store in y

    ,t                                         Range(10)
 (aR  y)                                       Replace each digit in input with
                                                 corresponding element in prefix list
        ."ium"                                 Append "ium"
              R`ii|nnn`_@>1                    Reduce too-long runs of letters
P                                              Print

 {y@a@0}Ma                                     For each digit in input, get first character
                                                 of corresponding prefix
Y                                              Store that list in y
          UC:y@0                               Uppercase the first item of y in place
                y                              Print y (items concatenated)

Le traitement de iiand nnnutilise un remplacement de regex avec une fonction de rappel (ajoutée dans la version la plus récente de Pip): pour chaque correspondance de ii|nnn, prenez tous les caractères sauf le premier et utilisez-les en remplacement.


Protip: Bien que l'inhalation d'autres entrées ne donne pas nécessairement le cancer du poumon , elles ne sont probablement pas les meilleures pour votre santé.
Cyoce

14

GNU sed, 171 (unseptunium)

s/0/Nil/g
s/1/Un/g
s/2/Bi/g
s/3/Tri/g
s/4/Quad/g
s/5/Pent/g
s/6/Hex/g
s/7/Sept/g
s/8/Oct/g
s/9/Enn/g
s/$/ium/
h
s/[a-z]//g
G
s/./\L&/g
s/./\U&/
s/\n/ /
s/ii/i/g
s/nnn/nn/g

Je suppose que l'ordre dans lequel le nom et le symbole sont retournés n'a pas d'importance. Ici, le symbole vient en premier:

$ seq 180 190 | sed -f iupac.sed 
Uon unoctnilium
Uou unoctunium
Uob unoctbium
Uot unocttrium
Uoq unoctquadium
Uop unoctpentium
Uoh unocthexium
Uos unoctseptium
Uoo unoctoctium
Uoe unoctennium
Uen unennilium
$ 

4
Je ne pense pas que les deux derniers remplacent le besoin g; les seuls cas seraient biium/ triiumet ennnil, tous ne pouvant se produire qu'une seule fois par moins de 1000.
PurkkaKoodari

8

Mathematica, unhexunium 163 161 octets

capitalise maintenant le symbole

Ceci est Mathematica sans la fonction intégrée ElementData.

f=StringReplace[##<>"ium, "<>{ToUpperCase@#1,##2}~StringTake~1&@@ToString/@nil[un,bi,tri,quad,pent,hex,sept,oct,enn][[IntegerDigits@#]],{"ii"->"i","nnn"->"nn"}]&

Test sur 10 nombres aléatoires:

# -> f[#]& /@ RandomInteger[{118, 558}, 10] // ColumnForm

155->unpentpentium, Upp
338->tritrioctium, Tto
477->quadseptseptium, Qss
261->bihexunium, Bhu
158->unpentoctium, Upo
164->unhexquadium, Uhq
266->bihexhexium, Bhh
331->tritriunium, Ttu
404->quadnilquadium, Qnq
389->trioctennium, Toe

8

JavaScript (ES6) 164 (unhexquadium) 171

La capitalisation est la partie la plus délicate. (Test en FireFox)

Éditez 3 octets sauvegardés thx user2786485

f=n=>[([...n+(l='')].map(c=>(c='nil,un,bi,tri,quad,pent,hex,sept,oct,enn'.split`,`[c],n=l?n+c[0]:c[0].toUpperCase(),l+=c)),l+'ium').replace(/i(i)|n(nn)/g,'$1$2'),n]

function test() { O.innerHTML=f(+I.value) }

test()

for(o='',i=99;i++<999;)o+=i+' '+f(i)+'\n';P.innerHTML=o
<input id=I onchange="test()" value="164"><span id=O></span><pre id=P></pre>


Retourne *eniumau lieu de *enniumpour tout ce qui est*9
DankMemes

Version Unhexhexium: n => [([... n] .map (c => (c = 'nil, un, bi, tri, quad, pent, hex, sept, oct, enn'.split`, `[ c], i = c [0], s = s? s + i: i.toUpperCase (), c), s = ''). join`` + 'ium'). remplacer (/ ii | nnn / g , r => r.slice (1)), s]
Mama Fun Roll

@molarmanful [...n]échouera pour un paramètre int. Le défi est d'environa given positive integer
edc65 10/10

Vous pouvez obtenir unhexoctium si vous remplacez votre appel de remplacement parreplace(/i(i)|n(nn)/g,'$1$2')
Hope I Can Help

@ user2786485 thx je pensais utiliser des captures mais je n'ai pas trouvé le bon chemin
edc65

7

Ruby - 163 156 147 143 134 (Untriquadium) octets

o=u='';gets.bytes{|c|k=%w[Nil un bI trI quad pent hex sept oct enN Ium][c%48];o+=k;u+=k[0]};puts o.tr_s('IN','in'),u[0..-2].capitalize

J'espère jouer au golf de cette façon

Edit: Merci pour @steveverrill pour avoir réduit de 9 octets!

Edit2: Merci encore pour @steveverrill pour encore 4 octets! (Solution vraiment intelligente!)


1
1. Au lieu de each_charvous pouvez utiliser chars. Selon la documentation officielle Ruby est ce « désapprouvée » (mais pas codegolf!) Vous auriez probablement faire mieux avec each_byteou bytespuis c.to_idevient par exemple i%48. 2. Aussi par hasard \na le code ascii 10, alors vous pouvez peut-être vous débarrasser de la chopet l'inclure iumdans votre tableau (fonctionne très bien pour le nom de l'élément, mais ajoute un caractère parasite iau symbole de l'élément.)
Level River St

1
Vous pouvez économiser 5 autres octets avec tr_sce qui suit:o=u='';gets.bytes{|c|k=%w[Nil un bI trI quad pent hex sept oct enN Ium][c%48];o+=k;u+=k[0]};puts o.tr_s('IN','in'),u[0..-2].downcase.capitalize
Level River St

u.chopest plus court que u[0..-2]. J'aurais peut-être dû poster ma propre réponse, mais mon idée initiale était de le faire exactement comme vous l'avez fait. C'est amusant de t'aider à jouer au golf. J'ai complètement manqué que vous n'avez pas besoin downcaseavant capitalize.
Level River St

7

Pyth, 67 octets (Holmium)

rshMJ@Lcs@LGjC"]ß!âÿeóÑiSÑA¼R¬HE"24\fjQT3-"ium"epj"nn"csJ*\n3

Essayez-le en ligne dans le compilateur / exécuteur Pyth .

Comment ça fonctionne

            jC"…"24       Convert the string from base 256 to base 24.
        s@LG              Select the letter that corresponds to each digit.
       c           \f     Split at 'f'.
     @L              jQT  Select the chunk that corresponds to each input digit.
    J                     Save in J.
 shM                      Form a string of the first letters of the chunks.
r                       3 Capitalize the first character.
                          Print. (implicit)

             csJ*\n3      Split the flattened J at "nnn".
        j"nn"             Join, separating by "nn".
       p                  Print.
-"ium"e                   Remove the last character ('i'?) from "ium".
                          Print. (implicit)

6

JavaScript (ES6), 210 202 octets ( Biunnilium Binilbium)

Moins octium (8) octets, grâce à @ edc65!

130 159 147 octets (Untrinilium Unpentennium Unquadseptium)

f=z=>(c=(b=(z+"").split``.map(x=>"nil.un.bi.tri.quad.pent.hex.sept.oct.enn".split`.`[+x])).join``.replace(/nnn/g,"n"))+(c[c.length-1]!="i"?"i":"")+"um,"+(a=b.map(x=>x[0])).shift().toUpperCase()+a.join``

Entrée comme f(324). Ugh, je me sentais tellement golf-y.


@ edc65 Correction des trois problèmes.
Conor O'Brien

1
Bien. Maintenant, en utilisant des modèles de chaînes, vous pouvez éviter certains crochets et économiser peut-être 8 octets. Codegolf.stackexchange.com/a/52204/21348
edc65

6

CJam, 74 72 71 70 69 octets (Thulium)

r:i"ؾaÈÁaÎE<Ä+&:¬úD±"380b24b'af+)/f=_:c(euoS@s'n3*/"nn"*)"ium"|

Notez que le code contient des caractères non imprimables.

Merci à @ Sp3000 d'avoir signalé une erreur dans ma révision initiale et d'avoir suggéré l' )/approche.

Essayez en ligne à l' interprète CJAM: .

Comment ça fonctionne

r:i     e# Read a token and push the array of its character codes.
"…"     e# Push a string of unprintable characters.
380b24b e# Convert it from base 380 to base 24.
'af+    e# Add the character 'a' to each base-24 digit.
        e# This pushes "bijtrijquadjpentjhexjseptjoctjennjniljunj".
)/      e# Pop the last character and split the string at the remaining occurrences.
f=      e# For each character code in the input, select the correspoding chunk.
_:c     e# Push a copy and cast each string to character.
(euo    e# Shift out the first character, convert to uppercase, and print.
S@      e# Push a space and rotate the array of string on top of it.
s       e# Flatten the array of string.
'n3*/   e# Split at occurrences of "nnn". 
"nn"*   e# Join, using "nn" as separator.
)"ium"| e# Pop the last character and perform setwise union with "ium".
        e# If the last character is, e.g., 't', this pushes "tium".
        e# If the last character is 'i', this pushes "ium".

3
Fait amusant: Le tungstène est souvent utilisé dans les lingots et les pièces de monnaie contrefaits en raison de son extrême densité comparable à celle de l'or et de son prix relativement bas.
lirtosiast 10/10

1
Lutetium est un nom absurdement cool pour un élément.
T. Sar - Réintégrer Monica

@ThalesPereira Encore plus froid qu'Ytterbium?
Beta Decay

Fait amusant: Erbium, terbium, yttrium et ytterbium portent tous le même nom .
lirtosiast

5

Matlab, 170 (Unseptnilium)

Fonctionne sur toutes les entrées que vous pouvez lancer, de niliumhaut en bas, aussi loin que vous le souhaitez. J'y suis arrivé ennennennennennennennennennennennennennennennennennennennennennenniumavant d'abandonner avec l'appui de la touche 9.

l=['nubtqphsoe';'inirueeecn';'l  ianxptn';'    dt t  '];i=input('','s')-47;s=l(1,i);s(1)=s(1)-32;a=l(:,i);disp([strrep(strrep([a(a>32)' 'ium '],'nnn','nn'),'ii','i') s]);

Et une explication:

%Create a 2D array of the prefixes transposed
l=['nubtqphsoe';'inirueeecn';'l  ianxptn';'    dt t  '];
%Grab the input number
i=input('','s')     %Request the input and convert to string
               -47; %Convert from ASCII into an array of indecies (1 indexed)
%Generate the short form
s=l(1,i);
%Capitalise first letter in short form
s(1)=s(1)-32;
%Extract required prefixes for long form
a=l(:,i);
%Now the fun bit:
                     a(a>32)'                                    %Combine the prefixes removing spaces and transpose into a string
                    [         'ium ']                            %Append 'ium ' to the string (the space is to separate the short form)
             strrep(                 ,'nnn','nn')                %Replace 'nnn' with 'nn'
      strrep(                                    ,'ii','i')      %Replace 'ii' with 'i'
disp([                                                     s]); %And display both full and short form strings together

5

TI-BASIC, 223 218 octets

Input N
"nil un  bi  tri quadpenthex septoct enn→Str4
"int(10fPart(N/10^(X→Y₁
"sub(Str4,1+4Y₁,int(3fPart(e^(Y₁)1.5154)+2^not(X=2 and .9=fPart(N%) or X=1 and 1=int(5fPart(.1N→Y₂
"ium,"+sub("UBTQP",int(N%),1
For(X,1,3
Y₂+Ans+sub(Y₂(3-X),1,1
End
sub(Ans,1,length(Ans)-1

L'élément numéro N ne peut avoir un triple "n" que s'il se termine par 90, et ne peut avoir un double "i" que si le dernier chiffre est 2 ou 3. Nous utilisons les mathématiques pour vérifier ces cas.

Le nombre magique 1.5154, qui stocke la longueur de chaque préfixe, a été trouvé en utilisant un script Python pour rechercher toutes les décimales de longueur ≤ 7 en utilisant les fonctions cosh(, cos(et e^(.

Pas encore de jouer au golf, mais les lettres minuscules à deux octets et le manque de commandes de manipulation des cordes de TI-BASIC vont, comme toujours, nuire au score de ce programme.


Je vais travailler sur le golf. ^ _ ^ Je vous ferai savoir ce que je propose.
Conor O'Brien

Je ne pense pas que quiconque puisse réduire ce nombre à 118 ou moins, mais si quelqu'un réussit, je donnerai 500 représentants.
lirtosiast

Deux questions: Qu'est-ce que N% et que sont "" et ""?
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Désolé,% est un jeton de deux octets que vous ne pouvez pas saisir dans votre calculatrice. Utilisez le logiciel SourceCoder de Cemetech ou les outils de TI pour le modifier dans la source ou utilisez le fichier fourni.
lirtosiast

@ CᴏɴᴏʀO'Bʀɪᴇɴ  est l'indice 10; - Je l'ai remplacé par un 10 normal.
lirtosiast

2

Python 3, unpentquadium ( 156 155 154) octets

n=e=""
for c in input():s="nil un bi tri quad pent hex sept oct enn".split()[int(c)];n+=s[c<"1"<"nn"==n[-2:]:];e+=s[0]
print(n.strip("i")+"ium",e.title())

Plutôt que de remplacer iipar un irenvoi, nous renversons les is avant de virer de bord ium, car c’est la seule source possible de double is. De la même manière, nous décapons ns en recherchant un enn/nilcas.



2

CJam, 95 octets

liAbA,"nil un bi tri quad pent hex sept oct enn"S/er_:c(eu\+_1>"en"={\W"il"t\}&S@:+)_'i=!*"ium"

Essayez-le en ligne

Ceci entre en compétition dans la catégorie "langages sans regex, et n'utilisant que des caractères imprimables". ;) Je ne m'attendais pas vraiment à une solution aussi courte que certaines des solutions déjà publiées, mais j'étais curieuse de savoir combien de temps elle durerait. Et depuis que je l’ai maintenant, je pourrais aussi bien le poster.

Explication:

li      Get input and convert to int.
Ab      Encode in decimal.
A,      Build list [0 .. 9].
"..."   String with prefixes.
S/      Split at spaces.
er      Transliterate. We now have a list of the prefix for each digit.
_:c     Copy and take first character of each, for short form.
(       Pop off first character.
eu      Convert it to upper case.
\+      Put it back in place. Done with short form.
_1>     Remove first character.
"en"=   Compare with "en", corresponding to the 90 special case.
{       Handle 90 case, replace 
  \       Swap full prefix list to top.
  W"il"t  Replace "nil" by "il" to avoid "nnn".
  \       Swap short form back to top.
}&      End of 90 case.
S       Push space between short form and full name.
@       Swap prefix list to top.
:+      Concatenate all the prefixes.
)       Pop off the last letter.
_'i=    Compare it with 'i.
!*      Multiply letter with comparison result. This gets rid of letter if it's 'i.
"ium"   Add the final part of the output.

1
Juste pour référence, Dennis ne sauvegarde que 6 octets avec tout ce codage de base: P
Sp3000

1

Go, 322 octets (tribibium)

package main
import("os"
"strings"
"fmt")
func main(){p,n,s:="nil un  bi  tri quadpenthex septoct enn ","",make([]byte,0)
b:=make([]byte,3)
os.Stdin.Read(b)
var d byte=32
for _,r:=range b{i:=r-48
n+=p[4*i:4*i+4]
s,d=append(s,p[4*i]-d),0}
fmt.Printf("%sium %s",strings.NewReplacer(" ","","ii","i","nnn","nn").Replace(n),s)}

Lit trois caractères de STDIN, plus sont ignorés, moins de résultats dans un crash. Donc, cela fonctionne pour chaque nombre compris entre unnilniliumet ennennennium.


De plus, l'élément pour 322 octets ne devrait-il pas être tribibinium? 321 est tribiunium.
Mateon1

Zut, j'ai raté celui-là en ajoutant le "i". Maintenant tout devrait être en ordre
Fabian Schmengler

1

PowerShell, 170 168 165 (Unhexpentium)

-join($a="$input"[0..9]|%{(($x=(-split'Nil Un Bi Tri Quad Pent Hex Sept Oct Enn')["$_"]).ToLower(),$x)[!($y++)]})+'ium'-replace'(nn)n|(i)i','$1$2'
-join($a|%{$_[0]})

Assez simple et sans surprises ici. Sauf peut-être que j'ai résolu le problème de la capitalisation en mettant les minuscules tout sauf la première partie et en ayant les différentes parties déjà dans le titre. Désormais, il est impérativement intégré pour éviter de perdre des caractères lors d’affectations de variables nues.

Bonus après le dernier changement: fonctionne désormais pour les numéros d'élément plus longs:

> echo 1337| powershell -noprofile -file "element.ps1"
Untritriseptium
Utts

1

C sur x86, 192 (Unennbium)

int c,s,a[8],x,main(){while((c=getchar()-48)>=0)x="nil\0un\0\0bi\0\0tri\0quadpenthex\0septoct\0enn"+4*c,strncat(a,x+(c<s-8),4),strncat(a+5,x,1),s=c;printf("%s%s %s",a,"ium"+((s&14)==2),a+5);}

Lit les chiffres stdinet imprime les résultats dans stdout. S'appuie sur sizeof(char*) == sizeof(int).

Version non-golfée:

int c, s, // Current and last digit, initially zero (0-9, not '0'-'9')
    a[8], // Buffer to write to (type doesn't matter when passed by pointer)
    x; // Int-pointer into lookup table

main() {
    while ((c = getchar() - 48) >= 0) { // 48 == '0'
        x = "nil\0un\0\0bi\0\0tri\0quadpenthex\0septoct\0enn" + 4*c;
        strncat(a, x+(c<s-8), 4); // Write digit, skip first char if c==0 && s==9
        strncat(a+5, x, 1); // Write first digit character somewhere else
        s = c;
    }
    printf("%s%s %s", a, "ium"+((s&14)==2), a+5); // Append "ium" (or "um" if s==2||s==3)
}

1

Haskell, bipentbium ( 305 271 269 265 261 259 253 252 octets)

import Data.Char
main=getLine>>=putStr.a
m=map toLower
a n=(r.m$p)++(k.filter isUpper$p)where p=(n>>=(words"Nil Un Bi Tri Quad Pent Hex Sept Oct Enn"!!).digitToInt)++"ium "
r('n':'n':'n':x)="nn"++r x
r('i':'i':x)='i':r x
r(x:z)=x:r z
r x=x 
k(h:t)=h:m t

Rasé 34 octets grâce à Nimi.


1
Vous pouvez hardcode la nnnet les iicas dans r, par exemple r('i':'i':a)='i':r a;r('n':'n':'n':a)="nn"++r a;r(x:a)=x:r a;r x=xet l' appeler sans arguments: t=r.m.p.
nimi

@nimi Bravo pour ça!
Jkabrg

1
Encore quelques octets à sauvegarder: concatMapis >>=, c'estp n=(n>>=(words"..."!!))++"ium "
nimi

@nimi encore une fois.
Jkabrg

1

GNU sed, unhexunium (161 octets)

h
y/0123456789/nubtqphsoe/
s/./\u&/
x
s/$/ium/
:
s/0/nil/
s/1/un/
s/2/bi/
s/3/tri/
s/4/quad/
s/5/pent/
s/6/hex/
s/7/sept/
s/8/oct/
s/9/enn/
s/nnn/nn/
s/ii/i/
t
G

Je génère d'abord le symbole, puis le cache dans un espace réservé et crée le nom. Une boucle est plus golfeuse que l’utilisation /gde quatre remplacements ou plus (nous ne pouvons avoir qu’un iiet / ou un nnn, ils n’ont donc pas besoin d’être à l’intérieur de la boucle, mais cela ne fait pas mal). Enfin, récupérez et ajoutez le symbole maintenu.

(NB: je n'avais pas vu la réponse sed existante quand j'ai écrit ça)

Cas de test

Ces règles iiet nnnrègles spéciales:

$ seq 100 89 1000 | ./60208.sed
unnilnilium
Unn
unoctennium
Uoe
biseptoctium
Bso
trihexseptium
Ths
quadpenthexium
Qph
pentquadpentium
Pqp
hextriquadium
Htq
septbitrium
Sbt
octunbium
Oub
ennilunium
Enu
ennennilium
Een

Et un ridicule, montrant combien ce code donne plus par rapport au monde physique:

$ ./60208.sed <<<281039817
bioctunniltriennoctunseptium
Bounteous

1

T-SQL 329 octets

creat proc x(@a char(3))as select replace(replace((select a.b as[text()]from(select left(@a,1)a union select substring(@a,2,1)union select right(@a,1))z join(values(0,'nil'),(1,'un'),(2,'bi'),(3,'tri'),(4,'quad'),(5,'pent'),(6,'hex'),(7,'sept'),(8,'oct'),(9,'enn'))a(a,b)on z.a=a.a for xml path(''))+'ium','ii','i'),'nnn','nn')

Formaté:

create proc x(@a char(3))as 
select replace(replace(
(select a.b as[text()]from
    (
    select left(@a,1)a 
    union select substring(@a,2,1)
    union select right(@a,1))z 
join(values(0,'nil'),(1,'un'),(2,'bi'),(3,'tri'),(4,'quad'),(5,'pent'),(6,'hex'),(7,'sept'),(8,'oct'),(9,'enn')
    )a(a,b)on z.a=a.a 
for xml path('')
)+'ium','ii','i'),'nnn','nn')

1

PHP, 152 153 163 octets, unpentbium

Eh bien, au moins PHP est quelque part autour de la moyenne cette fois-ci.

while(null!=$x=$argv[1][$i++]){$a.=$y=[nil,un,bi,tri,quad,pent,hex,sept,oct,enn][$x];$b.=$y[0];}echo str_replace([ii,nnn],[i,nn],$a.'ium ').ucfirst($b);

Fonctionne en ligne de commande comme:

pentium.php 163

Sortie:

unhextrium Uht

Ungolfed

$y = array('nil','un','bi','tri','quad','pent','hex','sept','oct','enn');

while (null != ($x = $argv[1][$i++])) {
    $a .= $y[$x];
    $b .= $y[$x][0];
}

echo str_replace(
        array('ii','nnn'),
        array('i','nn'),
        $a . 'ium ')
     .ucfirst($b);

Modifier

  • sauvé 10 octets en remplaçant tout (pas seulement un, duh ) array()-initializer par[]
  • enregistré 1 octet en ajoutant les espaces blancs avec à la 'ium 'place en utilisant une concaténation supplémentaire.' '.

0

Perl, 109 octets

108 code + 1 commutateur

perl -pe 's!.!qw{Nil Un Bi Tri Quad Pent Hex Sept Oct Enn}[$&]!ge;s!nnN!nN!g;s!i?$!ium!;$_=lc$_.y!a-z!!dr;s!\b.!\U$&!g'

Prend l'entrée de STDIN sous la forme d'un nombre par ligne.


Vous voulez dire un n ilseptium :)
CompuChip

Ah, merci de le signaler :) Corrigé maintenant
15:55 svsd

0

Java 8 216 octets

String f(int i){
String[] s = {"nil","un","bi","tri","quad","pent","hex","sept","oct","enn"};
return ((""+i).chars().mapToObj(y->s[y-48]).collect(Collectors.joining())+"ium").replace("ii","i").replace("nnn","n");
}

3
Bienvenue dans Programming Puzzles & Code Golf! 1. Votre code, sous la forme d'un programme complet ou d'une fonction, doit accepter un entier comme entrée et générer le nom approprié. 2. Cela ne tient pas compte de iiet nnn, comme expliqué dans la question. 3. L'objectif du code golf est de rendre le code aussi court que possible. La réponse devrait contenir son score dans le titre. Vous pouvez réduire votre score en éliminant les espaces et en raccourcissant le nom de la variable.
Dennis

@ Dennis Merci! mais pourquoi compter les espaces blancs? cela rend le code encore plus illisible.
Rnet

3
@Rnet L'objectif n'est pas de rendre le code lisible. ;) De plus, certains espaces peuvent être importants, il n’est donc pas évident de savoir lesquels compter ou non. Par conséquent, la réponse doit supprimer autant d’espaces que possible et simplement compter les octets de cette version. Si vous souhaitez fournir une version lisible avec l'indentation appropriée, vous pouvez toujours le faire séparément sous le code compté. Voir consensus pertinent sur la méta.
Martin Ender

0

C # 229 (Bibiennium) 198 octets unennoctium

Le truc "n-'0" est un moyen de convertir d'asci en int. Caractère 9 = ASCII 57. Caractère 0 = ASCII 48, donc 57-48 = 9.

Chaîne privée statique ToText (int v) {return (string.Join ("", v.ToString (). Select.) ((char n) => "rien ne trie pent pent hex sept oct enn" .Split () [n -'0 '])) + "ium"). Remplacez ("nnn", "nn"). Remplacez ("ii", "i") + "" + string.Join ("", v.ToString () .Select ((char n) => "nubtqphsoe" [n-'0 '])); }

    static private string ToText(int  v)
    {
        string u,r="",t="";
        return v.ToString().Select((char n)=>{u="nil un bi tri quad pent hex sept oct enn".Split()[n-48];r+=u;t+=u[0];return r;}).Last()+"ium".Replace("nnn","nn").Replace("ii","i")+" "+t;
    }

Cette approche prend l'int, convertit en chaîne, puis effectue une sélection de caractères LINQ qui se déclenche avec un lambda.

Le lambda génère un tableau à la volée (moins de caractères que sa définition) en scindant la chaîne de préfixes. Il extrait ensuite l'index du préfixe à utiliser en regardant la valeur int du caractère actuel (astuce n-'0 'mentionnée ci-dessus).

Tout cela est enveloppé dans une chaîne.Join qui concatène tous les résultats LINQ ensemble. Cliquetez sur le "ium", puis quelques déclarations. Remplacez à la fin pour nettoyer les nnn 'et ii.

Ajout de la sortie de symbole manquante. Je pense qu'il existe un moyen plus efficace de fusionner les deux LINQ, mais il est trop tard pour continuer à le fouiller.


Au lieu de n-'0', pourquoi pas n-30?
undergroundmonorail

Bon appel, mais cela dépend du jeu de caractères. 48 fonctionne pour moi cependant;)
Rick Way

0

C, 210 204 unennennium (199) octets

Cela nécessite ASCII en tant que jeu de caractères d'exécution.

f(char*n,char*s){char*c="NilUnBiTriQuadPentHexSeptOctEnn",*p,*o=n,i,j;for(;*n;){for(j=i=*n-48,p=c;*p&32||i--;++p);for(*s++=*n=*p+32;*++p&32;)*s++=*p;s-=*n++-j==39||j/2-*n==1;}*o-=32;strcpy(s,"ium");}

J'ai essayé une solution récursive (qui évite le besoin de pet o) mais cela s'est avéré plus long.

Je suis particulièrement fier / honte de l'matcher pour l'expression rationnelle 90|[23]$, qui repose sur 9et 0étant le plus éloigné séparé chiffres (et donc la seule paire qui diffèrent par 9 - le 39dans le code est une conséquence d' jêtre une valeur entière , et *nencore une ASCII caractère) et que 2et 3diffèrent seulement dans le dernier bit, divisant par 2 les confond.

Code développé:

void f(char *n,                 /* input number / output symbol */
       char *s)                 /* output name */
{
    char *c = "NilUnBiTriQuadPentHexSeptOctEnn", /* digit names */
        *p,
        *o = n,                 /* first char of input */
        i, j;                   /* current digit value */
    for (;*n;) {
        j = i = *n-48;
        for (p=c;  *p&32 || i--;  ++p) /* Find the i'th capital letter in c */
                ;
        for (*s++ = *n++ = *p++ + 32;  *p&32;  ) /* Downcase and copy following lowercase */
            *s++ = *p++;
        s -= *n-j==39 || j/2-*n==1;   /* backup one if 9 is followed by 0, or if 2 or 3 is at end of input */
    }
    *o -= 32;                   /* Capitalise symbol */
    strcpy(s,"ium");            /* Finish name */
}

Harnais de test:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    char buf[1024];
    while (*++argv) {
        f(*argv, buf);
        printf("%s %s\n", *argv, buf);
    }
    return EXIT_SUCCESS;
}

0

R, 278 octets

g<-function(x){k<-data.frame(c("nil","un","bi","tri","quad","pent","hex","sept","oct","enn"));row.names(k)<-0:9;n<-unlist(strsplit(as.character(x),""));return(sub("nnn","nn",sub("ii","i",paste(c(as.vector(k[n,]),"ium"," ",sapply(k[n,],function(x)substr(x,1,1))),collapse=""))))}

Pas le meilleur ... mais j'apprends toujours R alors j'ai pensé poster ma tentative. Des suggestions pour le rendre meilleur? Maintenant que j'y pense, il est probablement possible de créer un sous-ensemble sur la première ligne plutôt que de perdre de l'espace en créant des noms de ligne.

Exemple d'utilisation

> g(118)
[1] "ununoctium uuo"
> g(999)
[1] "ennennennium eee"
> g(558)
[1] "pentpentoctium ppo"
> g(118)
[1] "ununoctium uuo"
> g(90)
[1] "ennilium en"
> g(2)
[1] "bium b"

Ungolfed

g <- function(x) {
    k <- data.frame(c("nil","un","bi","tri","quad","pent","hex","sept","oct","enn"))
    row.names(k) <- 0:9
    n <- unlist(strsplit(as.character(x),""))
    return(
        sub("nnn", "nn", sub("ii", "i", paste(c(as.vector(k[n,]),"ium"," ", sapply(k[n, ],function(x)substr(x,1,1))), collapse = ""))))
}
  1. Créer une clé, convertir en trame de données et définir comme variable k
  2. Définissez les noms de ligne comme 0-9pour une identification facile
  3. Prenez l’entrée x, convertissez-la en caractère, divisez-la (par exemple, 137 en "1" "3" "7")
  4. Sous-ensemble kbasé sur l'entrée du numéro divisé et renvoyer les entrées
  5. Concaténez-les et ajoutez -ium
  6. kUtilisez également une sous- chaîne pour extraire la première lettre des correspondances. Ceci est concaténé à la sortie de l'étape 5 avec un espace vide entre eux
  7. Utiliser sub()pour remplacer les motifs nnnetii

Vous avez oublié de mettre la première lettre du symbole en majuscule. Par exemple, ce devrait être "Uuo", pas "uuo", pour 118.
Alexander Revo

0

Javascript - 169 octets

n=>eval(`q='nil0un0bi0tri0quad0pent0hex0sept0oct0enn'.split(0);for(b of (_=$='')+n){c=q[b];$+=q[b];_+=(_?c:c.toUpperCase())[0]}$.replace(/i$()|n(nn)/g,'$1$2')+'ium '+_`)

Bizarrement, mes tentatives d'utiliser map ont été plus longues que la boucle for.

EDIT: Oups, j'ai oublié de vérifier la date.


0

PHP, 131 + 1 octets (untriunium)

encore terriblement long:

for(;~$c=$argn[$i];print$i++?$n[0]:$n&_)$r.=$n=[nil,un,bi,tri,quad,pent,hex,sept,oct,enn][$c];echo strtr(_.$r.ium,[ii=>i,nnn=>nn]);

Exécuter en pipe -nRou essayer en ligne .


-1

Python, 154 octets

import re
n=input('')
for c in n:
 print(re.sub('ii','i',re.sub('nnn','nn',['nil','un','bi','tri','quad','pent','hex','sept','oct','enn'][int(c)]+'ium')))

Ce code produit une sortie non valide.
Alexander Revo
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.