(Literalmente: "¿Esto sigue / se da cuenta de la forma gismu ?")

Premisa

El lenguaje Lojban es un lenguaje construido , lo que significa en parte que todas sus palabras se han creado en lugar de permitir que se desarrollen naturalmente. La base semántica de Lojban son sus gismu , o palabras raíz, que se sintetizaron combinando raíces de lenguas naturales ampliamente habladas como el chino, el hindi y el inglés. Todos los gismu tienen 5 letras de largo y siguen una cierta forma estricta.

Información

Para nuestros propósitos, el alfabeto lojban es:

abcdefgijklmnoprstuvxz

Es decir, el alfabeto romano sin hqwy.

Este alfabeto se puede dividir en cuatro categorías:

• Vocales aeiou

• Consonantes sonoras lmnr

• Consonantes sordas ptkfcsx. Cuando se expresa, estos se convierten respectivamente en ...

• Consonantes sonoras bdgvjz(ninguna consonante sonora corresponde a x).

Para ser un gismu válido, una cadena de 5 caracteres debe:

1. Estar en uno de los patrones de vocal consonante CVCCVo CCVCV, donde C representa una consonante y V representa una vocal.

2. Siga las reglas de correspondencia de consonantes.

Reglas de coincidencia de consonantes para palabras CCVCV:

Los primeros dos caracteres deben constituir uno de los siguientes 48 pares ( fuente ):

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

Tenga en cuenta que esto se ve bastante mejor cuando se separa en pares con voz y sin voz. En particular, cada par sonoro-sonoro es válido si el par sordo-sonoro correspondiente es válido. Esto no se extiende a pares con una consonante sonora; cles válido pero jlno lo es.

Reglas de coincidencia de consonantes para palabras CVCCV ( fuente ):

El tercer y cuarto caracteres deben seguir las siguientes reglas:

1. Está prohibido que ambas consonantes sean iguales [...]

2. Está prohibido que una consonante se exprese y la otra no se exprese. Las consonantes "l", "m", "n" y "r" están exentas de esta restricción. Como resultado, "bf" está prohibido, y también lo está "sd", pero se permiten tanto "fl" como "vl", y "ls" y "lz".

3. Está prohibido que ambas consonantes se extraigan del conjunto "c", "j", "s", "z".

4. Los pares específicos "cx", "kx", "xc", "xk" y "mz" están prohibidos.

Tenga en cuenta que hay 179 pares posibles.

Reto

Determine si la cadena dada sigue las reglas de formación de gismu . Este es el código de golf , por lo que gana la solución más corta en bytes.

Entrada : Una cadena de longitud 5 del alfabeto Lojban.

Salida : un valor verdadero si la cadena puede ser un gismu y un valor falsey de lo contrario.

Casos de prueba

Válido:

gismu
cfipu
ranxi
mupno
rimge
zosxa

Inválido:

ejram
xitot
dtpno
rcare
pxuja
cetvu

Más casos de prueba: este archivo de texto contiene todos los gismu válidos, uno por línea.

_{Realmente no conozco a Lojban, así que sospecho que la traducción del título es incorrecta. La ayuda es apreciada.}

Rubí, 302 252 bytes

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

Se podrían guardar algunos bytes más de la siguiente manera:

Inicializar za falso usando z=!c='[cjsztdpbfvkgxmnlr]'. Esto funciona pero da la advertencia warning: found = in conditional, should be ==.

Cambiar de un programa a una función (lo dejé como un programa porque, según la pregunta, gana el "programa" más corto en bytes).

Resumen de cambios de la primera publicación

Revisión importante de la expresión regular / parte correspondiente.

La constante 72 cambió a 69 para que el código ASCII más bajo en la cadena mágica sea 10 en lugar de 13. Esto permite que se use una nueva línea literal en la versión de golf en lugar de una secuencia de escape.

La cadena mágica 'mzxcxkx'reemplaza las reglas aritméticas de los 5 caracteres prohibidos en la tabla de tipos CVCCV.

versión sin golf

espacio en blanco agregado y cambio de nueva línea en una cuerda mágica a \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

Explicación de la correspondencia

Los dos caracteres en la cadena de entrada s[n,2]se comparan con el par de caracteres del bucle iterativo. Si coinciden y el patrón de expresión regular vocal-consonante es correcto, i,jse verifica la validez de los valores de fila y columna . El ordenamiento cuidadoso de las consonantes ayuda aquí.

Para 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.

Para CCVCV

Un mapa de bits para cada columna de la tabla a continuación se codifica en la cadena mágica, de la cual se resta 69. Para todas las columnas, excepto las dos últimas, solo se requieren 6 bits. Para los dos últimos, los bits de orden superior deben ser 1, por lo que se genera un número negativo (caracteres \ny :) para tener 1 en lugar de ceros a la izquierda. Sin embargo, no queremos incluir las últimas tres filas de la tabla, por lo que en lugar de cambio de derechos y AND por 1, cambiamos de derecho y AND por lo 1-j/14que normalmente se evalúa a 1, pero se evalúa a 0 para las últimas 3 filas.

El siguiente programa (con las mismas expresiones que el envío) se utilizó para generar las tablas a continuación (descomente la iflínea que se requiera para la tabla que desee.

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 bytes

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

Explicación

Devuelve una matriz que contiene la última letra (verdad) si es un gismu válido o nullsi no lo es.

Gran parte del tamaño proviene de los CCVCVpares codificados (incluso después de condensarlos). ¡Es posible encontrar un patrón para generarlos, pero ya he pasado demasiado tiempo en esto! 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])

Prueba

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 bytes

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

Supongo que este es mi trabajo ahora.