(Literalmente: "Será que este acompanhamento / perceber a gismu -forma?")

Premissa

A linguagem Lojban é uma linguagem construída , o que significa em parte que todas as suas palavras foram criadas e não permitidas a se desenvolver naturalmente. A base semântica do Lojban são seus gismu , ou palavras-raiz, que foram sintetizadas pela combinação de raízes de idiomas naturais amplamente falados, como chinês, hindi e inglês. Todos os gismu têm 5 letras e seguem uma certa forma estrita.

Em formação

Para nossos propósitos, o alfabeto Lojban é:

abcdefgijklmnoprstuvxz

Ou seja, o alfabeto romano sem hqwy.

Este alfabeto pode ser dividido em quatro categorias:

• Vogais aeiou

• Consoantes sonoras lmnr

• Consoantes não sonoras ptkfcsx. Quando dublados, tornam-se respectivamente os ...

• Consoantes bdgvjzsonoras (nenhuma consoante sonora corresponde a x.)

Para ser um gismu válido, uma string de 5 caracteres deve:

1. Esteja em um dos padrões consoante-vogal CVCCVou CCVCV, em que C representa uma consoante e V representa uma vogal.

2. Siga as regras de correspondência de consoantes.

Regras de correspondência consoante para palavras CCVCV:

Os dois primeiros caracteres devem constituir um dos 48 pares a seguir ( origem ):

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

Observe que isso parece melhor quando separado em pares sonoros e sonoros. Em particular, cada par sonoro é válido se o par sonoro correspondente não sonoro for válido. Isso não se estende a pares com uma consoante sonora; clé válido, mas jlnão é.

Regras de correspondência de consoantes para palavras CVCCV ( fonte ):

O terceiro e o quarto caracteres devem seguir as seguintes regras:

1. É proibido que ambas as consoantes sejam as mesmas [...]

2. É proibido que uma consoante seja dublada e a outra não dublada. As consoantes "l", "m", "n" e "r" estão isentas desta restrição. Como resultado, "bf" é proibido, e "sd", mas "fl" e "vl" e "ls" e "lz" são permitidos.

3. É proibido que ambas as consoantes sejam extraídas do conjunto “c”, “j”, “s”, “z”.

4. Os pares específicos "cx", "kx", "xc", "xk" e "mz" são proibidos.

Observe que existem 179 pares possíveis.

Desafio

Determine se a sequência fornecida segue as regras de formação do gismu . Isso é código-golfe , então a solução mais curta em bytes vence.

Entrada : uma sequência de comprimento 5 do alfabeto Lojban.

Saída : um valor verdadeiro se a string puder ser um gismu e um valor Falsey contrário.

Casos de teste

Válido:

gismu
cfipu
ranxi
mupno
rimge
zosxa

Inválido:

ejram
xitot
dtpno
rcare
pxuja
cetvu

Mais casos de teste: esse arquivo de texto contém todo o gismu válido, um por linha.

_{Eu realmente não conheço Lojban, então suspeito que a tradução do título esteja errada. A ajuda é apreciada.}

Ruby, 302252 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

Mais alguns bytes podem ser salvos da seguinte maneira:

Inicialize zpara false usando z=!c='[cjsztdpbfvkgxmnlr]'. Isso funciona, mas dá o avisowarning: found = in conditional, should be == .

Mude de um programa para uma função (deixei como programa porque, de acordo com a pergunta, o menor "programa" em bytes vence.)

Resumo das alterações da primeira postagem

Revisão principal da regex / parte correspondente.

A constante 72 foi alterada para 69, de modo que o código ASCII mais baixo da seqüência mágica seja 10 em vez de 13. Isso permite que uma nova linha literal seja usada na versão em golfe em vez de uma sequência de escape.

Corda mágica 'mzxcxkx' substitui as regras aritméticas dos 5 caracteres proibidos na tabela de tipos CVCCV.

versão ungolfed

espaço em branco adicionado e mudança de nova linha na string mágica para um \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

Explicação da correspondência

Os dois caracteres na sequência de entrada s[n,2]são comparados com o par de caracteres do loop de iteração. Se eles corresponderem e o padrão de regex consoante-vogal estiver correto, os valores de linha e colunai,j serão verificados quanto à validade. A ordenação cuidadosa das consoantes ajuda aqui.

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

Um bitmap para cada coluna da tabela abaixo é codificado na sequência mágica, da qual 69 é subtraído. Para todas as colunas, exceto as duas últimas, são necessários apenas 6 bits. Nos dois últimos, os bits de ordem superior precisam ser 1, de modo que um número negativo é gerado (caracteres \ne :) para ter 1s iniciais em vez de zeros iniciais. No entanto, não queremos incluir as três últimas linhas da tabela; portanto, em vez de shift de direitos e AND por 1, shift de direitos e AND pelo 1-j/14qual normalmente é avaliado como 1, mas é avaliado como 0 nas últimas 3 linhas.

O programa a seguir (com as mesmas expressões do envio) foi usado para gerar as tabelas abaixo (descomente a iflinha que for necessária para a tabela que você deseja).

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

Explicação

Retorna uma matriz contendo a última letra (verdade) se for um gismu válido ou nullse não for.

Muito do tamanho vem dos CCVCVpares codificados (mesmo após condensá-los). Pode ser possível encontrar um padrão para gerá-los, mas já gastei muito tempo com isso! 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])

Teste

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

Acho que esse é o meu trabalho agora.