Nazwy elementów powyżej 118

46

IUPAC w swojej nieznośnej mądrości stworzyli systematyczną nazwę elementu dla każdego nowo utworzonego elementu. Jest to tymczasowa nazwa elementu, dopóki w końcu nie zdecydują się na prawdziwą nazwę. Działa to tak: każda cyfra numeru elementu ma przypisany prefiks na podstawie jego wartości. Prefiksy są łączone z „ium” na końcu. Kiedy to zrobisz i jeśli otrzymasz podwójne i's (ii) lub potrójne n's (nnn), zamień je na pojedyncze i's i podwójne n's. Symbolem elementu jest pierwsza litera każdego użytego prefiksu połączonego i skapitalizowanego wyniku. Użyte prefiksy znajdują się poniżej.

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

Więc dla tego golfa twój kod musi wygenerować zarówno nazwę elementu, jak i jego symbol dla danej dodatniej liczby całkowitej. Więc jeśli twój kod otrzymał 137, powinien wypisać na standardowe wyjście lub zwrócić oba untriseptiumi Uts. Powinien być ważny od co najmniej 118 do 558 . Każda wyższa jest poprawna, jeśli nie zwiększa długości kodu.

Przykład Pythona przedstawiający metodę:

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 wygrywa bajtami kadmu!

Status
źródło
34
Zacznę nazywać Boron nazwą systemową IUPAC: „Pentium”
Michael,
24
@Michael Intel Boron Processor
Beta Decay
1
Czy musimy mieć prawidłową skrzynkę?
lirtosiast
6
@BetaDecay Ale czy ten „piąty element” obsługuje MultiPass ?
Damian Yerrick

Odpowiedzi:

22

Mathematica 10.1, ind (49) kadm (48)

To rozwiązanie wykorzystuje wbudowaną bibliotekę właściwości elementów, w tym nazw i skrótów IUPAC. (Nie widziałem tej techniki, której należy unikać w golfie. Wydaje się to być zachęcane. Ale może to być (być może ponad) akceptowalne - Mathematica implementuje tę bibliotekę (i wiele innych), pobierając dane z Serwery Wolfram przy pierwszym użyciu (i przypuszczam, że czasami sprawdzam aktualizacje).)

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

Jak by to wyglądało w porównaniu do używania elements.py lub periodictable.py w Pythonie?

Edycja: Kilka miesięcy później: Zauważyłem, że napisałem na maszynie kod wyjściowy 122. Ponownie uruchomiłem kod i sprawdziłem, że popełniłem ten błąd, a nie Mathematica.

Eric Towers
źródło
9
Kiedy pisałem wyzwanie, pomyślałem: „Czy powinienem zapobiegać wbudowanym funkcjom? Nie, to mało prawdopodobne, że jest ono wbudowane w dowolny język. Czekaj, Mathematica może to mieć”. Ale nie wiedziałem, jak to sprawdzić, a potem szybko o tym zapomniałem.
Status
7
Święte nawiasy, Batman! Ten akapit wygląda na coś, co mogłem napisać (ja też jestem winny używania na bok nawiasów w celu złagodzenia mojej gadatliwości - zazwyczaj takie są).
cole
1
Można zapisać jeden bajt za pomocą wewnętrznej zastosować i co fsobie czystą funkcję: f=ElementData@@@{{#,"Abbreviation"},{#,"Name"}}&.
Czy ten kod nie stanie się nieważny dla 118, jeśli dany element zyska oficjalną nazwę?
1
@ ais523: Zgodnie ze specyfikacją „Więc dla tego golfa twój kod musi wygenerować zarówno nazwę elementu, jak i jego symbol dla danej dodatniej liczby całkowitej”. Jeśli element ma nazwę lub symbol, należy podać tę nazwę lub symbol. Według Twoich danych każde inne przesłanie na tej stronie nie spełni specyfikacji, jeśli jakikolwiek element o liczbie atomowej> = 118 otrzyma systematyczny symbol lub nazwę.
Eric Towers
27

Python 3, Unhexseptium (167) bajtów

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())

Są to wyniki, gdy program działa na każdej liczbie od 1 do 999 (włącznie)

Rozpad beta
źródło
30
Twój nagłówek sprawia, że ​​chcę, aby wszyscy wymienili w ten sposób liczbę bajtów.
Status
4
@Status Słuchaj, słuchaj. To sprawi, że ci Pythowie będą bardzo smutni ... :)
zlewka
1
@beaker Jestem rozczarowany, że Twoje zdjęcie profilowe nie jest Beaker ;)
Beta Decay
4
@BetaDecay Gotowe.
zlewka
6
@Status: jeśli komuś uda się to zrobić w mniej niż 112 bajtach, może mieć klasyczną nazwę elementu w tytule :) Jak rutherfordium . Lub złoto .
vsz
15

Pip , Thorium Actinium Radon (86)

(Nie wdychaj tego wpisu, bo dostaniesz raka płuc.)

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

Pobiera numer elementu jako argument wiersza polecenia i wyświetla nazwę i skrót w osobnych wierszach.

Objaśnienie (nieco nie golfa):

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)

iiI nnnobsługi używa regex zastąpienie funkcji wywołania zwrotnego (dodana w najnowszej wersji PIP): dla każdego meczu ii|nnn, podejmie wszelkie ale pierwszy znak i używać jako zamiennik.

DLosc
źródło
Protip: Wdychanie innych wpisów może nie wywołać raka płuc , ale prawdopodobnie nie są one najlepsze dla twojego zdrowia.
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

Zakładam, że nie ma znaczenia, w jakiej kolejności zwracane są nazwa i symbol. Tutaj symbol jest pierwszy:

$ 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
$ 
Cyfrowa trauma
źródło
4
Nie sądzę, żeby ostatnie dwa miejsca wymagały g; jedynymi przypadkami byłyby biium/ triiumi ennnilwszystkie mogą się zdarzyć tylko raz w liczbach poniżej 1000.
PurkkaKoodari 10.10.2015
8

Mathematica, unhexunium 163 161 bajtów

teraz wielkie litery symbol

To jest Mathematica bez wbudowanego 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 na 10 liczbach losowych:

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

źródło
8

JavaScript (ES6) 164 (unhexquadium) 171

Wielkie litery to trudna część. (Test w FireFox)

Edytuj 3 bajty zapisane przez użytkownika 2786485

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>

edc65
źródło
Zwraca *eniumzamiast *enniumczegokolwiek, co*9
DankMemes
Wersja Unhexhexium: n => [([... n] .map (c => (c = 'zero, un, bi, tri, quad, pent, hex, sept, oct, enn'.split`, `[ c], i = c [0], s = s? s + i: i.toUpperCase (), c), s = ''). join '' + 'ium'). replace (/ ii | nnn / g , r => r.slice (1)), s]
Mama Fun Roll
@molarmanful [...n]nie powiedzie się dla parametru int. Wyzwanie jest okołoa given positive integer
edc65,
Możesz dostać unhexoctium, jeśli zastąpisz swoje wezwanie „zamień” nareplace(/i(i)|n(nn)/g,'$1$2')
Mam nadzieję, że mogę pomóc
@ user2786485 thx Myślałem o użyciu przechwytywania, ale nie znalazłem właściwej drogi
edc65
7

Rubin - 163 156 147 143 134 134 (Untriquadium) bajtów

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

Mam nadzieję zagrać w golfa w ten sposób

Edycja: Dzięki za @steveverrill za stratę 9 bajtów!

Edit2: Jeszcze raz dziękuję za @steveverrill za kolejne 4 bajty! (Naprawdę sprytne rozwiązanie!)

Peter Lenkefi
źródło
1
1. Zamiast each_charciebie możesz użyć chars. Według oficjalnej dokumentacji Rubiego jest to „przestarzałe” (ale nie w codegolf!) Prawdopodobnie lepiej byś to zrobił, each_bytea bytespotem c.to_ina przykład stanie się i%48. 2. Również przez przypadek \nma kod ascii 10, więc może możesz się go pozbyć chopi dołączyć iumdo swojej tablicy (działa świetnie dla nazwy elementu, ale dodaje fałszywy isymbol elementu).
Level River St
1
Możesz zapisać kolejne 5 bajtów w tr_snastępujący sposób: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.chopjest krótszy niż u[0..-2]. Może powinienem był opublikować własną odpowiedź, ale moim początkowym pomysłem było zrobienie tego dokładnie tak, jak ty to zrobiłeś. Fajnie było grać w golfa. I całkowicie brakowało, że nie trzeba downcasewcześniej capitalize.
Level River St
7

Pyth, 67 bajtów (Holmium)

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

Wypróbuj online w Pyth Compiler / Executor .

Jak to działa

            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)
Dennis
źródło
6

JavaScript (ES6), 210 202 bajtów ( Biunnilium Binilbium)

Minus octium (8) bajtów, dzięki @ edc65!

130 159 147 bajtów (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``

Dane wejściowe jak f(324). Ugh, czułem się bardzo golfowo.

Conor O'Brien
źródło
@ edc65 Naprawiono wszystkie trzy problemy.
Conor O'Brien,
1
W porządku. Teraz, używając ciągów szablonów, możesz uniknąć niektórych nawiasów klamrowych i zaoszczędzić może 8 bajtów codegolf.stackexchange.com/a/52204/21348
edc65 10.1015
6

CJam, 74 72 71 70 70 69 bajtów (Thulium)

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

Pamiętaj, że kod zawiera znaki niedrukowalne.

Dzięki @ Sp3000 za wskazanie błędu w mojej początkowej wersji i zasugerowanie )/podejścia.

Spróbuj go online w tłumacza CJam: .

Jak to działa

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".
Dennis
źródło
3
Ciekawostka: Wolfram jest często stosowany w fałszywych sztabkach złota i monetach, ze względu na jego ekstremalną gęstość porównywalną do złota i jego względną taniość.
lirtosiast,
1
Lutet to absurdalnie fajna nazwa pierwiastka.
T. Sar - Przywróć Monikę
@ThalesPereira Ale nawet fajniejszy niż Ytterbium?
Beta Decay
Ciekawostka: Erb, terb, itr i iterbium są nazwane po tym samym miejscu .
lirtosiast
5

Matlab, 170 (Unseptnilium)

Działa na wszystkich wejściach, które możesz na niego rzucić, od, niliumaż do tak daleko, jak chcesz. Udało mi się, ennennennennennennennennennennennennennennennennennennennennennenniumzanim zrezygnowałem z naciskania klawisza 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]);

I wyjaśnienie:

%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
Tom Carpenter
źródło
5

TI-BASIC, 223 218 bajtów

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

Element o numerze N może mieć potrójne „n”, jeśli kończy się na 90, a może mieć podwójne „i”, jeśli ostatnia cyfra to 2 lub 3. Używamy matematyki do sprawdzania tych przypadków.

Magiczna liczba 1.5154, która przechowuje długość każdego prefiksu, został znaleziony przy użyciu skryptu Python przeszukać wszystkie dziesiętne długości ≤7 używając funkcji cosh(, cos(oraz e^(.

Nie skończyłem jeszcze gry w golfa, ale dwubajtowe małe litery TI-BASIC i brak poleceń manipulacji ciągami, jak zwykle, zaszkodzą wynikowi tego programu.

lirtosiast
źródło
Popracuję nad golfem. ^ _ ^ Dam ci znać, co wymyślę.
Conor O'Brien,
Nie sądzę, aby ktokolwiek mógł obniżyć to do 118 lub mniej, ale jeśli komuś się uda, dam 500 powtórzeń.
lirtosiast
Dwa pytania: Co to jest N%, a czym są „” i „”?
Conor O'Brien,
@ CᴏɴᴏʀO'Bʀɪᴇɴ Przepraszamy,% to dwubajtowy token, którego nie można wpisać do kalkulatora. Użyj SourceCoder lub narzędzi TI Cemetech , aby edytować go w źródle lub użyj pliku , który podałem .
lirtosiast,
@ CᴏɴᴏʀO'Bʀɪᴇɴ  to indeks dolny 10; Zastąpiłem go zwykłym 10.
lirtosiast 10.10.15
2

Python 3, unpentquadium ( 156 155 154) bajtów

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())

Zamiast wymieniać iiz imy rstrip żadnych is zanim przyczepność na ium, ponieważ jest to możliwe jedynie źródłem podwójnych is. Podobnie usuwamy ns, sprawdzając enn/nilprzypadek.

Sp3000
źródło
2

Retina, 206 196 186 179 (Unseptennium) bajtów ( Wypróbuj online )

Dzięki @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) za nauczenie mnie tego języka.

Dzięki @FryAmTheEggman za odcięcie 7 bajtów.

T`d`nubtq\p\hs\oe
.+
$&, $&
(?<=,.*n)
il
(?<=,.*e)n?
nn
(?<=,.*u)
n
(?<=,.*b)
i
(?<=,.*t)
ri
(?<=,.*q)
uad
(?<=,.*p)
ent
(?<=,.*h)
ex
(?<=,.*s)
ept
(?<=,.*o)
ct
r`i?$
ium
T`l`L`^.

Wersja bajtowa: tutaj

Wersja B-bajtowa: tutaj

Leaky Nun
źródło
2

CJam, 95 bajtów

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

Wypróbuj online

To konkuruje w kategorii „języki bez wyrażeń regularnych i tylko przy użyciu znaków do wydrukowania”. ;) Tak naprawdę nie spodziewałam się, że będzie on tak krótki jak niektóre z już opublikowanych rozwiązań, ale byłem ciekawy, jak długo by to się skończyło. A skoro mam go teraz, równie dobrze mogę go opublikować.

Wyjaśnienie:

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.
Reto Koradi
źródło
1
Dla porównania, Dennis zapisuje tylko 6 bajtów z całym tym podstawowym kodowaniem: P
Sp3000,
1

Idź, 322 bajtów (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)}

Odczytuje trzy znaki ze STDIN, więcej jest ignorowanych, mniej powoduje awarię. Działa to dla każdej liczby między unnilniliumi ennennennium.

Fabian Schmengler
źródło
Ponadto, czy element 322 bajtów nie powinien być tribibinium? 321 to tribiunium.
Mateon1,
Cholera, tęskniłem za dodaniem „i”. Teraz wszystko powinno być w porządku
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]})

Dość proste i bez niespodzianek. Może z wyjątkiem tego, że rozwiązałem problem wielkich liter, odsuwając na bok wszystko oprócz pierwszej części i mając poszczególne części już w tytule. Agresywnie nakreślone do tej pory, aby uniknąć utraty znaków dla przypisań do zmiennej.

Premia po ostatniej zmianie: teraz działa również na dłuższe liczby elementów:

> echo 1337| powershell -noprofile -file "element.ps1"
Untritriseptium
Utts
Joey
źródło
1

C na 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);}

Odczytuje cyfry stdini drukuje wyniki stdout. Polega na sizeof(char*) == sizeof(int).

Wersja bez golfa:

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)
}
trion
źródło
1

Haskell, bipentbium ( 305 271 269 265 261 259 253 252 bajtów)

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

Ogolono 34 bajty dzięki nim.

jkabrg
źródło
1
Można hardcode nnni iiprzypadki, w r, tzn r('i':'i':a)='i':r a;r('n':'n':'n':a)="nn"++r a;r(x:a)=x:r a;r x=xi nazywają go bez argumentów: t=r.m.p.
nimi
@nimi Pozdrawiam za to!
jkabrg,
1
Jeszcze kilka bajtów do zapisania: concatMapto >>=znaczyp n=(n>>=(words"..."!!))++"ium "
nimi
@nimi Pozdrawiam ponownie.
jkabrg,
1

GNU sed, unhexunium (161 bajtów)

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

Najpierw generuję symbol, a następnie chowam go do miejsca i tworzę nazwę. Pętla jest bardziej golfowa niż używanie /gczterech lub więcej zamienników (możemy mieć tylko jeden iii / lub jeden nnn, więc nie muszą znajdować się w pętli, ale to nie boli). Na koniec pobierz i dołącz trzymany symbol.

(Uwaga: nie widziałem istniejącej odpowiedzi sed, kiedy to napisałem)

Przypadki testowe

Wykonują one iii nnnspecjalne zasady:

$ 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

I niedorzeczny, pokazujący o ile więcej ten kod daje w porównaniu ze światem fizycznym:

$ ./60208.sed <<<281039817
bioctunniltriennoctunseptium
Bounteous
Toby Speight
źródło
1

T-SQL 329 bajtów

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')

Sformatowany:

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')
Sam cd
źródło
1

PHP, 152 153 163 bajty, niepentbium

Tym razem przynajmniej PHP jest gdzieś średnio.

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

Działa z wiersza polecenia, takiego jak:

pentium.php 163

Wynik:

unhextrium Uht

Bez golfa

$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);

Edytować

  • zaoszczędził 10 bajtów, zastępując cały (nie tylko jeden, duh ) array()-inicjalizator[]
  • zaoszczędzono 1 bajt, dodając białe znaki oraz 'ium 'zamiast tego stosując dodatkową konkatenację.' '.
wstawić nazwę tutaj
źródło
0

Perl, 109 (Unnilennium) bajtów

Kod 108 + 1 przełącznik

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'

Pobiera dane wejściowe ze STDIN jako jedną liczbę w wierszu.

svsd
źródło
Masz na myśli un n ilseptium :)
CompuChip
Ach, dziękuję za zwrócenie na to uwagi :)
Naprawiłem
0

Java 8 216 bajtów

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");
}
Rnet
źródło
3
Witamy w Programowaniu Puzzle i Code Golf! 1. Twój kod, w postaci pełnego programu lub funkcji, powinien przyjmować liczbę całkowitą jako dane wejściowe i generować odpowiednią nazwę. 2. To nie uwzględnia iii nnn, jak wyjaśniono w pytaniu. 3. Celem gry w golfa jest uczynienie kodu możliwie jak najkrótszym. Odpowiedź powinna zawierać wynik w tytule. Możesz zmniejszyć swój wynik, eliminując białe znaki i skracając nazwę zmiennej.
Dennis
@Dennis Thanks! ale po co liczyć białe znaki? sprawia, że ​​kod jest jeszcze bardziej nieczytelny.
Rnet
3
@Rnet Celem nie jest uczynienie kodu czytelnym. ;) Również niektóre białe znaki mogą być znaczące, więc nie jest oczywiste, które białe znaki należy liczyć, a które nie. Dlatego odpowiedź powinna usunąć jak najwięcej białych znaków i po prostu policzyć bajty tej wersji. Jeśli chcesz zapewnić czytelną wersję z odpowiednim wcięciem, zawsze możesz to zrobić osobno poniżej zliczonego kodu. Zobacz odpowiedni konsensus w sprawie meta.
Martin Ender
0

C # 229 (Bibiennium) 198 bajtów unennoctium

Sztuczka „n-'0” jest sposobem na konwersję z ascii na int. Char 9 = ASCII 57. Char 0 = ASCII 48, więc 57-48 = 9.

statyczny prywatny ciąg ToText (int v) {return (string.Join ("", v.ToString (). Wybierz ((char n) => "zero bic quad pent hex hex sept oct enn" .Split () [n -'0 '])) + „ium”). Zamień („nnn”, „nn”). Zamień („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;
    }

To podejście przyjmuje int, konwertuje na ciąg, a następnie wykonuje LINQ wybór znaków, które odpalają lambda.

Lambda generuje tablicę w locie (mniej znaków niż ją definiuje), dzieląc ciąg prefiksów. Następnie pobiera indeks prefiksu do użycia, patrząc na wartość int bieżącego znaku (sztuczka n-0 wspomniana powyżej).

Wszystko to jest zawinięte w ciąg. Połącz, który łączy wszystkie wyniki LINQ razem. Tack na „ium”, a następnie kilka .Replace na końcu, aby oczyścić nnn i ii.

Dodano brakujące wyjście symbolu. Myślę, że istnieje bardziej skuteczny sposób, łącząc dwa LINQ, ale jest już za późno, aby się na niego szturchać.

Rick Way
źródło
Zamiast tego n-'0'dlaczego nie n-30?
undergroundmonorail
Dobre połączenie, ale zależy to od zestawu znaków. 48 działa jednak dla mnie;)
Rick Way,
0

C, 210 204 unennennium (199) bajtów

Wymaga to ASCII jako zestawu znaków środowiska wykonawczego.

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

Wypróbowałem rozwiązanie rekurencyjne (które pozwala uniknąć potrzeby pi o), ale okazało się, że było dłużej.

Jestem szczególnie dumny / wstydzić dopasowującego do regexp 90|[23]$, która opiera się 9i 0jest najdalej oddzielone cyfry (a więc tylko parę, które różnią się od 9 - 39w kodzie jest konsekwencją jjest liczbą całkowitą i *nnadal ASCII charakter) i to 2i 3różnią się tylko ostatnim bitem, więc dzielenie przez 2 łączy je.

Rozszerzony kod:

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 */
}

Uprząż testowa:

#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;
}
Toby Speight
źródło
0

R, 278 bajtów

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

Nie najlepsze ... ale wciąż uczę się R, więc pomyślałem, że opublikuję moją próbę. Jakieś sugestie, żeby to poprawić? Teraz, gdy o tym myślę, prawdopodobnie możliwe jest podzbiór wiersza n-1 zamiast marnowania miejsca na tworzenie nazw wierszy.

Przykładowe użycie

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

Bez golfa

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. Utwórz klucz, przekonwertuj na ramkę danych i ustaw jako zmienną k
  2. Ustaw nazwy wierszy, 0-9aby ułatwić ich identyfikację
  3. Weź dane wejściowe x, przekonwertuj na znak, podziel je (np. 137 na „1” „3” „7”)
  4. Podzbiór koparty na wprowadzonym numerze podzielonym i zwraca wpisy
  5. Połącz je razem i dodaj -ium
  6. Podzbiór również kza pomocą podciągów, aby wyciągnąć pierwszą literę dopasowań. Jest to konkatenowane z wynikiem z kroku 5 z pustą przestrzenią między nimi
  7. Służy sub()do zastępowania wzorów nnniii
syntonicC
źródło
Zapomniałeś wielkich liter pierwszej litery. Na przykład powinna być „Uuo”, a nie „Uuo” dla 118.
Alexander Revo
0

JavaScript - 169 bajtów

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 '+_`)

Dziwnie, moje próby użycia mapy były dłuższe niż pętla for.

EDYCJA: Ups, zapomniałem sprawdzić datę.

Marcus Dirr
źródło
0

PHP, 131 + 1 bajtów (untriunium)

wciąż okropnie długo:

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]);

Uruchom jako potok z -nRlub spróbuj online .

Tytus
źródło
-1

Python, 154 bajty

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')))
Hipe99
źródło
Ten kod generuje nieprawidłowe dane wyjściowe.
Alexander Revo