（从字面上看：“这是否遵循/实现了gismu -form？”）

前提

Lojban语言是一种构造语言，部分意味着其所有单词都是被创造的，而不是自然发展的。Lojban的语义基础是其gismu或词根词，它们是通过组合来自广泛使用的自然语言（如中文，印地语和英语）的词根而合成的。所有gismu的长度均为5个字母，并遵循一定的严格格式。

信息

就我们的目的而言，罗伊班字母是：

abcdefgijklmnoprstuvxz

也就是说，罗马字母不带hqwy。

该字母可以分为四类：

• 元音 aeiou

• 辅音辅音 lmnr

• 清音辅音ptkfcsx。发出声音时，它们分别成为...

• 浊辅音bdgvjz（没有对应的浊辅音x。）

要成为有效的gismu，长度为5个字符的字符串必须：

1. 在子音元音模式CVCCV或中CCVCV，其中C表示辅音，V表示元音。

2. 遵循辅音匹配规则。

CCVCV单词的辅音匹配规则：

前两个字符必须构成以下48个对之一（源）：

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

请注意，将其分为浊音对和浊音对时，效果会更好。特别地，每个浊音对都是有效的，前提是相应的浊音对有效。这不会扩展到与子音辅音对。cl是有效的，但jl不是。

CVCCV单词的辅音匹配规则（来源）：

第三个和第四个字符必须遵循以下规则：

1. 禁止两个辅音都相同[...]

2. 禁止一个辅音发声而另一个不发声。辅音“ l”，“ m”，“ n”和“ r”不受此限制。结果，“ bf”被禁止，“ sd”也被禁止，但是“ fl”和“ vl”以及“ ls”和“ lz”都被允许。

3. 禁止从集合“ c”，“ j”，“ s”，“ z”中提取两个辅音。

4. 禁止使用特定的对“ cx”，“ kx”，“ xc”，“ xk”和“ mz”。

请注意，有179个可能的对。

挑战

确定给定的字符串是否符合gismu形成规则。这是代码高尔夫球，因此以字节为单位的最短解决方案为准。

输入：从Lojban字母开始的长度为5的字符串。

输出：一个truthy值如果字符串可以是gismu和否则falsey值。

测试用例

有效：

gismu
cfipu
ranxi
mupno
rimge
zosxa

无效：

ejram
xitot
dtpno
rcare
pxuja
cetvu

更多测试用例：此文本文件包含所有有效gismu，每行一个。

_{我不太了解Lojban，所以我怀疑标题翻译错误。感谢帮助。}

红宝石，302 252个字节

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

可以再保存一些字节，如下所示：

使用初始化z为false z=!c='[cjsztdpbfvkgxmnlr]'。这有效，但发出警告warning: found = in conditional, should be ==。

从程序更改为功能（我将其保留为程序，因为根据问题，以字节为单位的最短“程序”获胜。）

第一篇文章的变更摘要

正则表达式/匹配部分的大修。

将常数72更改为69，以使魔术字符串中的最低ASCII码为10而不是13。这使高尔夫球版本中可以使用文字换行符，而不必使用转义序列。

魔术字符串'mzxcxkx'替换了CVCCV类型表中5个禁止的字符的算术规则。

非高尔夫版本

添加空格并将魔术字符串中的换行符更改为 \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

匹配说明

将输入字符串s[n,2]中的两个字符与迭代循环的字符对进行比较。如果它们匹配并且辅音元音正则表达式模式正确，i,j则检查行和列值的有效性。仔细排序辅音在这里有帮助。

对于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.

对于CCVCV

下表中每一列的位图被编码为魔术字符串，从中减去69。对于除最后两列之外的所有列，仅需要6位。对于后两个，高阶位需要为1，因此会生成一个负数（字符\n和:），以便具有前导1而不是前导零。但是，我们不想包括表的最后三行，因此，我们将右移和AND而不是右移和与1，1-j/14而通常将其求值为1，但对于最后三行将其求值为0。

以下程序（具有与提交相同的表达式）用于生成以下表（取消注释if所需表的任何行）。

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），366352字节

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

说明

返回一个包含最后一个字母（真实）的数组（如果它是有效的gismu或null不是）。

许多大小来自硬编码CCVCV对（即使压缩后也是如此）。也许可以找到一种模式来生成它们，但是我已经花了太多时间了！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])

测试

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个字节

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

我想这是我现在的工作。