(Littéralement: "Est-ce que cela suit / réalise la forme gismu ?")

Prémisse

La langue Lojban est une langue construite , ce qui signifie en partie que tous ses mots ont été créés plutôt que autorisés à se développer naturellement. La base sémantique de Lojban est son gismu , ou mots racines, qui ont été synthétisés en combinant des racines de langues naturelles largement parlées comme le chinois, l'hindi et l'anglais. Tous les gismu font 5 lettres et suivent une certaine forme stricte.

Information

Pour nos besoins, l'alphabet lojban est:

abcdefgijklmnoprstuvxz

Autrement dit, l'alphabet romain sans hqwy.

Cet alphabet peut être divisé en quatre catégories:

• Voyelles aeiou

• Consonnes sonores lmnr

• Consonnes non vocales ptkfcsx. Une fois exprimés, ceux-ci deviennent respectivement le ...

• Consonnes voisées bdgvjz(aucune consonne voisée ne correspond à x.)

Pour être un gismu valide, une chaîne de 5 caractères doit:

1. Soyez dans l'un des modèles de voyelles consonnantes CVCCVou CCVCV, où C représente une consonne et V représente une voyelle.

2. Suivez les règles de correspondance des consonnes.

Règles d'appariement des consonnes pour les mots CCVCV:

Les deux premiers caractères doivent constituer l'une des 48 paires suivantes ( source ):

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

Notez que cela semble plutôt plus agréable lorsqu'il est séparé en paires voisées et non voisées. En particulier, chaque paire voix-voix est valide si la paire voix-non-voix correspondante est valide. Cela ne s'étend pas aux paires avec une consonne sonorante; clest valide mais jlne l'est pas.

Règles d'appariement des consonnes pour les mots CVCCV ( source ):

Les troisième et quatrième caractères doivent suivre les règles suivantes:

1. Il est interdit que les deux consonnes soient les mêmes [...]

2. Il est interdit de faire entendre une consonne et l'autre sans voix. Les consonnes «l», «m», «n» et «r» sont exemptées de cette restriction. Par conséquent, "bf" est interdit, de même que "sd", mais "fl" et "vl", ainsi que "ls" et "lz", sont autorisés.

3. Il est interdit de tirer les deux consonnes de l'ensemble «c», «j», «s», «z».

4. Les paires spécifiques «cx», «kx», «xc», «xk» et «mz» sont interdites.

Notez qu'il y a 179 paires possibles.

Défi

Déterminez si la chaîne donnée suit les règles de formation de gismu . Il s'agit de code-golf , donc la solution la plus courte en octets l'emporte.

Entrée : une chaîne de longueur 5 issue de l'alphabet Lojban.

Sortie : Une valeur véridique si la chaîne peut être un gismu et une valeur falsey sinon.

Cas de test

Valide:

gismu
cfipu
ranxi
mupno
rimge
zosxa

Invalide:

ejram
xitot
dtpno
rcare
pxuja
cetvu

Plus de cas de test: ce fichier texte contient tous les gismu valides, un par ligne.

_{Je ne connais pas vraiment Lojban, donc je soupçonne que la traduction du titre est fausse. L'aide est appréciée.}

Rubis, 302 252 octets

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

Quelques octets supplémentaires pourraient être enregistrés comme suit:

Initialiser zà false en utilisant z=!c='[cjsztdpbfvkgxmnlr]'. Cela fonctionne mais donne l'avertissement warning: found = in conditional, should be ==.

Passer d'un programme à une fonction (je l'ai laissé comme programme car selon la question, le "programme" le plus court en octets gagne.)

Résumé des changements depuis le premier message

Révision majeure de regex / pièce correspondante.

La constante 72 est passée à 69, de sorte que le code ASCII le plus bas de la chaîne magique est 10 au lieu de 13. Cela permet d'utiliser une nouvelle ligne littérale dans la version golfée au lieu d'une séquence d'échappement.

La chaîne magique 'mzxcxkx'remplace les règles arithmétiques pour les 5 caractères interdits dans la table de types CVCCV.

version non golfée

ajouté des espaces et changé la nouvelle ligne dans la chaîne magique en \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

Explication de l'appariement

Les deux caractères de la chaîne d'entrée s[n,2]sont comparés à la paire de caractères de la boucle d'itération. S'ils correspondent et que le modèle d'expression régulière de voyelle consonne est correct, la i,jvalidité des valeurs de ligne et de colonne est vérifiée. Un ordre soigneux des consonnes aide ici.

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

Pour CCVCV

Un bitmap pour chaque colonne du tableau ci-dessous est codé dans la chaîne magique, à partir de laquelle 69 est soustrait. Pour toutes les colonnes à l'exception des deux dernières, seuls 6 bits sont requis. Pour les deux derniers, les bits d'ordre supérieur doivent être 1, donc un nombre négatif est généré (caractères \net :) afin d'avoir des 1 en tête au lieu de zéros en tête. Cependant, nous ne voulons pas inclure les trois dernières lignes de la table.Au lieu de décalage des droits et AND par 1, nous modifions les droits et AND, 1-j/14ce qui correspond normalement à 1, mais à 0 pour les 3 dernières lignes.

Le programme suivant (avec les mêmes expressions que la soumission) a été utilisé pour générer les tableaux ci-dessous (décommenter la ifligne requise pour le tableau souhaité.

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 octets

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

Explication

Renvoie un tableau contenant la dernière lettre (véridique) s'il s'agit d'un gismu valide ou nulls'il ne l'est pas.

Une grande partie de la taille provient des CCVCVpaires codées en dur (même après les avoir condensées). Il pourrait être possible de trouver un modèle pour les générer, mais j'ai déjà passé trop de temps là-dessus! 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])

Tester

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 octets

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

Je suppose que c'est mon travail maintenant.