(Dosłownie: „Czy to następuje / realizuje formę gismu ?”)

Przesłanka

Język Lojban jest językiem skonstruowanym , co oznacza po części, że wszystkie jego słowa zostały stworzone, a nie rozwinięte w sposób naturalny. Podstawą semantyczną Lojban są gismu , czyli słowa rdzeniowe , które zostały zsyntetyzowane poprzez połączenie rdzeni z powszechnie używanych języków naturalnych, takich jak chiński, hindi i angielski. Wszystkie gismu mają 5 liter i mają ściśle określoną formę.

Informacja

Dla naszych celów alfabet Lojban to:

abcdefgijklmnoprstuvxz

Oznacza to, że alfabet rzymski bez hqwy.

Ten alfabet można podzielić na cztery kategorie:

• Samogłoski aeiou

• Spółgłoski Sonorant lmnr

• Bezdźwięczne spółgłosek ptkfcsx. Po wypowiedzeniu stają się odpowiednio ...

• Spółgłoski dźwięczne bdgvjz(żadna spółgłoska dźwięczna nie odpowiada x.)

Aby być prawidłowym gismu, ciąg o długości 5 znaków musi:

1. Być w jednym ze wzorów spółgłosek-samogłoski CVCCVlub CCVCV, gdzie C oznacza spółgłoskę, a V oznacza samogłoskę.

2. Przestrzegaj reguł dopasowywania spółgłoski.

Reguły dopasowania spójnego dla słów CCVCV:

Pierwsze dwa znaki muszą stanowić jedną z następujących 48 par ( źródło ):

ml mr
pl pr
bl br
   tr                   tc ts
   dr                   dj dz
kl kr
gl gr
fl fr
vl vr
cl cr cm cn cp ct ck cf
      jm    jb jd jg jv
sl sr sm sn sp st sk sf
      zm    zb zd zg zv
xl xr

Zauważ, że wygląda to ładniej, gdy jest podzielone na pary dźwięczne i bezdźwięczne. W szczególności każda para z dźwięcznym dźwiękiem jest ważna, jeśli odpowiednia para bezdźwięcznie bezdźwięczna jest ważna. Nie obejmuje to par ze spółgłoską sonorancką; cljest ważny, ale jlnie jest.

Reguły dopasowania spójnego dla słów CVCCV ( źródło ):

Trzeci i czwarty znak muszą przestrzegać następujących zasad:

1. Obie spółgłoski są takie same [...]

2. Zabrania się wyrażania jednej spółgłoski, a drugiej bezdźwięczności. Spółgłoski „l”, „m”, „n” i „r” są wyłączone z tego ograniczenia. W rezultacie „bf” jest zabronione, podobnie jak „sd”, ale dozwolone są zarówno „fl”, jak i „vl” oraz zarówno „ls”, jak i „lz”.

3. Zabrania się rysowania obu spółgłosek ze zbioru „c”, „j”, „s”, „z”.

4. Określone pary „cx”, „kx”, „xc”, „xk” i „mz” są zabronione.

Pamiętaj, że istnieje 179 możliwych par.

Wyzwanie

Ustal, czy podany ciąg znaków jest zgodny z regułami formowania gismu . To jest golf golfowy , więc wygrywa najkrótsze rozwiązanie w bajtach.

Dane wejściowe : ciąg o długości 5 z alfabetu Lojban.

Wyjście : prawdziwa wartość, jeśli łańcuch może być gismu, w przeciwnym razie wartość falsey.

Przypadki testowe

Ważny:

gismu
cfipu
ranxi
mupno
rimge
zosxa

Nieważny:

ejram
xitot
dtpno
rcare
pxuja
cetvu

Więcej przypadków testowych: ten plik tekstowy zawiera wszystkie prawidłowe gismu, po jednym w wierszu.

_{Tak naprawdę nie znam Lojbana, więc podejrzewam, że tłumaczenie tytułu jest nieprawidłowe. Pomoc jest doceniana.}

Rubinowy, 302 252 bajtów

c='[cjsztdpbfvkgxmnlr]'
v=c+'[aeiou]'
z=!1
n=/#{c+v+v}/=~(s=gets.chop)*2
(n==0||n==2)&&289.times{|k|q=[i=k%17,j=k/17].max
z||=(x=s[n,2])==c[j+1]+c[i+1]&&['UeUeJOJOJOJOETJ
:'[i].ord-69>>j&1-j/14>0,i!=j&&q>3&&(k%2<1||q>12)&&!'mzxcxkx'.index(x)][n/2]}
p z

Kilka dodatkowych bajtów można zapisać w następujący sposób:

Zainicjuj zna false, używając z=!c='[cjsztdpbfvkgxmnlr]'. To działa, ale daje ostrzeżenie warning: found = in conditional, should be ==.

Zmień program na funkcję (zostawiłem go jako program, ponieważ zgodnie z pytaniem wygrywa najkrótszy „program” w bajtach).

Podsumowanie zmian od pierwszego postu

Poważny przegląd części regularnej / dopasowania.

Stała 72 została zmieniona na 69, tak że najniższy kod ASCII w magicznym ciągu znaków to 10 zamiast 13. To pozwala na użycie dosłownego nowego wiersza w wersji golfowej zamiast sekwencji ucieczki.

'mzxcxkx'Liczby magiczne zastępują reguły arytmetyczne dla 5 zabronionych znaków w tabeli typów CVCCV.

wersja bez golfa

dodano biały znak i zmieniono znak nowej linii w magicznym ciągu znaków na \n

c='[cjsztdpbfvkgxmnlr]'                                   #c=consonants
v=c+'[aeiou]'                                             #v=consonant+vowel
z=!1                                                      #Set z to false (everything is truthy in Ruby except nil and false.)
n=/#{c+v+v}/=~(s=gets.chop)*2                             #Get input and duplicate it. do regex match, n becomes the index of the double consonant. 
(n==0||n==2)&&                                            #If n==0 (ccvcv) or n==2 (cvccv) 
   289.times{|k|                                          #iterate 17*17 times
     q=[i=k%17,j=k/17].max                                #generate row and column, find their maximum.
     z||=                                                 #OR z with the following expression:
     (x=s[n,2])==c[j+1]+c[i+1]&&                          #double consonant == the pair corresponding to j,i AND either 
       ["UeUeJOJOJOJOETJ\n:"[i].ord-69>>j&1-j/14>0,       #this expression or
       i!=j&&q>3&&(k%2<1||q>12)&&!'mzxcxkx'.index(x)][n/2]#this expresson, depending on the value of n/2
   }
p z                                                       #print output

Objaśnienie dopasowania

Dwa znaki w ciągu wejściowym s[n,2]są porównywane z parą znaków pętli iteracyjnej. Jeśli są zgodne, a wzór wyrażenia regularnego spółgłosek-samogłosek jest poprawny, wartości wiersza i kolumnyi,j są sprawdzane pod kątem ważności. Pomaga w tym staranne uporządkowanie spółgłosek.

W przypadku CVCCV:

i!=j                        It is forbidden for both consonants to be the same
(k%2<1||q>12)               It is forbidden for one consonant to be voiced and the other unvoiced. The consonants “l”, “m”, “n”, and “r” are exempt from this restriction. As a result, “bf” is forbidden, and so is “sd”, but both “fl” and “vl”, and both “ls” and “lz”, are permitted.
q>3                         It is forbidden for both consonants to be drawn from the set “c”, “j”, “s”, “z”.
!'mzxcxkx'.index(x)         The specific pairs “cx”, “kx”, “xc”, “xk”, and “mz” are forbidden.

Dla CCVCV

Bitmapa dla każdej kolumny poniższej tabeli jest zakodowana w magicznym ciągu, z którego odejmuje się 69. Dla wszystkich kolumn oprócz dwóch ostatnich wymagane jest tylko 6 bitów. Dla ostatnich dwóch bitów wyższego rzędu musi być 1, więc generowana jest liczba ujemna (znaki \ni :), aby mieć wiodące 1 zamiast wiodących zer. Nie chcemy jednak uwzględniać ostatnich trzech wierszy tabeli, więc zamiast przesunięcia w prawo i AND przez 1, przesuwamy w prawo i ORAZ, przez 1-j/14co normalnie jest to 1, ale w przypadku ostatnich 3 wierszy jest to 0.

Poniższy program (z tymi samymi wyrażeniami, co przesłanie) został użyty do wygenerowania poniższych tabel (odkomentuj którykolwiek ifwiersz jest wymagany dla tabeli, którą chcesz.

c='[cjsztdpbfvkgxmnlr]'
z=0
289.times{|k|
  q=[i=k%17,j=k/17].max
  r=c[j+1]+c[i+1]
  #if i!=j && q>3 && (k%2<1||q>12) && !'mzxcxkx'.index(r)
  #if "UeUeJOJOJOJOETJ\n:"[i].ord-69>>j&1-j/14>0
    print r,' '
    z+=1
  else
    print '   '
  end
  i==16&&puts 
}
puts z


            ct    cp    cf    ck       cm cn cl cr
               jd    jb    jv    jg    jm jn jl jr
            st    sp    sf    sk    sx sm sn sl sr
               zd    zb    zv    zg    zm zn zl zr
tc    ts          tp    tf    tk    tx tm tn tl tr
   dj    dz          db    dv    dg    dm dn dl dr
pc    ps    pt          pf    pk    px pm pn pl pr
   bj    bz    bd          bv    bg    bm bn bl br
fc    fs    ft    fp          fk    fx fm fn fl fr
   vj    vz    vd    vb          vg    vm vn vl vr
kc    ks    kt    kp    kf             km kn kl kr
   gj    gz    gd    gb    gv          gm gn gl gr
      xs    xt    xp    xf             xm xn xl xr
mc mj ms    mt md mp mb mf mv mk mg mx    mn ml mr
nc nj ns nz nt nd np nb nf nv nk ng nx nm    nl nr
lc lj ls lz lt ld lp lb lf lv lk lg lx lm ln    lr
rc rj rs rz rt rd rp rb rf rv rk rg rx rm rn rl 
179

            ct    cp    cf    ck       cm cn cl cr
               jd    jb    jv    jg    jm
            st    sp    sf    sk       sm sn sl sr
               zd    zb    zv    zg    zm
tc    ts                                        tr
   dj    dz                                     dr
                                             pl pr
                                             bl br
                                             fl fr
                                             vl vr
                                             kl kr
                                             gl gr
                                             xl xr
                                             ml mr


48

JavaScript (ES6), 366 352 bajtów

g=>((q=3,w=2,r=0,f="mzcscjzjxcxkx",c="bdgvjzptkfcsxlmnr",d=[...c],v="aeiou")[m="match"](g[1])?d.map((a,i)=>d.map((b,j)=>a==b|(i<6&j>5&j<13|j<6&i>5&i<13)||f[m](a+b)||(p+=","+a+b)),p="",q=0,r=w--)&&p:"jbl,zbr,tstcl,cmr,cn,cr,jdr,cfl,sfr,jgl,zgr,zdjml,ckl,skr,cpl,spr,sl,sm,sn,sr,ctr,jvl,zvr,xl,xr,dzm")[m](g[r]+g[r+1])&&c[m](g[q])&&v[m](g[w])&&v[m](g[4])

Wyjaśnienie

Zwraca tablicę zawierającą ostatnią literę (prawdę), jeśli jest to poprawny gismu lub nulljeśli nie jest.

Wiele rozmiarów pochodzi z zakodowanych CCVCVpar (nawet po ich kondensacji). Możliwe, że uda się znaleźć wzór do ich wygenerowania, ale spędziłem już na tym zbyt dużo czasu! xD

g=>
  (
    // Save the positions to check for the consonant, vowel and pair respectively
    (q=3,w=2,r=0,                       // default = CCVCV format
    f="mzcscjzjxcxkx",                  // f = all forbidden pairs for CVCCV pairs
    c="bdgvjzptkfcsxlmnr",              // c = consonants
    d=[...c],                           // d = array of consonants
    v="aeiou")                          // v = vowels
    [m="match"](g[1])?                  // if the second character is a vowel

      // Generate CC pairs of CVCCV
      d.map((a,i)=>                     // iterate over every possible pair of consonants
        d.map((b,j)=>
          a==b|                         // rule 1: consonants cannot be the same
          (i<6&j>5&j<13|j<6&i>5&i<13)|| // rule 2: pair cannot be voiced and unvoiced
          f[m](a+b)||                   // rule 3 & 4: certain pairs are forbidden
            (p+=","+a+b)                // if it follows all the rules add the pair
        ),
        p="",                           // p = comma-delimited valid CVCCV pairs
        q=0,r=w--                       // update the match positions to CVCCV format
      )&&p
    :
      // CC pairs of CCVCV (condensed so that valid pairs like "jb", "bl" and
      //     "zb" can be matched in this string but invalid pairs like "lz" cannot)
      "jbl,zbr,tstcl,cmr,cn,cr,jdr,cfl,sfr,jgl,zgr,zdjml,ckl,skr,cpl,spr,sl,sm,sn,sr,ctr,jvl,zvr,xl,xr,dzm"

  // Match the required format
  )[m](g[r]+g[r+1])&&c[m](g[q])&&v[m](g[w])&&v[m](g[4])

Test

var solution = g=>((q=3,w=2,r=0,f="mzcscjzjxcxkx",c="bdgvjzptkfcsxlmnr",d=[...c],v="aeiou")[m="match"](g[1])?d.map((a,i)=>d.map((b,j)=>a==b|(i<6&j>5&j<13|j<6&i>5&i<13)||f[m](a+b)||(p+=","+a+b)),p="",q=0,r=w--)&&p:"jbl,zbr,tstcl,cmr,cn,cr,jdr,cfl,sfr,jgl,zgr,zdjml,ckl,skr,cpl,spr,sl,sm,sn,sr,ctr,jvl,zvr,xl,xr,dzm")[m](g[r]+g[r+1])&&c[m](g[q])&&v[m](g[w])&&v[m](g[4])

<input type="text" id="input" value="gismu" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

JavaScript ES6, 240 bajtów

x=>eval(`/${(c='[bcdfgjklmnprstvxz]')+c+(v='[aeiou]')+c+v}/${t='.test(x)'}?/^[bfgkmpvx][lr]|[cs][fklmnprt]|d[jrz]|[jz][bdgmv]/${t}:/${c+v+c+c+v}/${t}?!/^..((.)\\2|${V='[bdgvjz]'}${U='[ptkfcsx]'}|${U+V}|[cjsz][cjsz]|cx|kx|xc|xk|mz)/${t}:!1`)

Myślę, że to teraz moja praca.