(Letteralmente: "Questo segue / realizza la forma gismu ?")

Premessa

Il linguaggio Lojban è un linguaggio costruito , il che significa in parte che tutte le sue parole sono state create piuttosto che consentire lo sviluppo naturale. La base semantica di Lojban è il suo gismu , o parole radice, che sono state sintetizzate combinando radici provenienti da lingue naturali ampiamente parlate come cinese, hindi e inglese. Tutti i gismu sono lunghi 5 lettere e seguono una certa forma rigorosa.

Informazione

Per i nostri scopi, l'alfabeto Lojban è:

abcdefgijklmnoprstuvxz

Cioè, l'alfabeto romano senza hqwy.

Questo alfabeto può essere diviso in quattro categorie:

• vocali aeiou

• Consonanti Sonorant lmnr

• Consonanti non fatturate ptkfcsx. Quando espressi, diventano rispettivamente il ...

• Consonanti sonore bdgvjz(nessuna consonante sonora corrisponde a x.)

Per essere un gismu valido, una stringa di 5 caratteri deve:

1. Essere in uno dei modelli di vocale consonante CVCCVo CCVCV, dove C rappresenta una consonante e V rappresenta una vocale.

2. Segui le regole di corrispondenza delle consonanti.

Regole di corrispondenza delle consonanti per le parole CCVCV:

I primi due caratteri devono costituire una delle seguenti 48 coppie ( fonte ):

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

Si noti che questo sembra piuttosto più bello se separato in coppie espresse e non. In particolare, ogni coppia con doppia voce è valida se è valida la corrispondente coppia senza fattura. Ciò non si estende alle coppie con una consonante sonora; clè valido ma jlnon lo è.

Regole di corrispondenza delle consonanti per le parole CVCCV ( fonte ):

Il terzo e il quarto carattere devono seguire le seguenti regole:

1. È vietato che entrambe le consonanti siano le stesse [...]

2. È vietato dare voce a una consonante e l'altra non fatturata. Le consonanti "l", "m", "n" e "r" sono esenti da questa limitazione. Di conseguenza, "bf" è proibito, così come "sd", ma sono consentiti sia "fl" e "vl", sia "ls" che "lz".

3. È vietato per entrambe le consonanti essere tratte dall'insieme “c”, “j”, “s”, “z”.

4. Le coppie specifiche "cx", "kx", "xc", "xk" e "mz" sono vietate.

Si noti che ci sono 179 coppie possibili.

Sfida

Determina se la stringa specificata segue le regole di formazione del gismu . Questo è code-golf , quindi vince la soluzione più breve in byte.

Input : una stringa di lunghezza 5 dall'alfabeto Lojban.

Output : un valore di verità se la stringa può essere un gismu e un valore di falsa in caso contrario.

Casi test

Valido:

gismu
cfipu
ranxi
mupno
rimge
zosxa

Non valido:

ejram
xitot
dtpno
rcare
pxuja
cetvu

Altri casi di test: questo file di testo contiene tutti i gismu validi, uno per riga.

_{Non conosco davvero Lojban, quindi sospetto che la traduzione del titolo sia errata. L'aiuto è apprezzato.}

Rubino, 302 252 byte

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

Alcuni byte in più potrebbero essere salvati come segue:

Inizializza zsu false usando z=!c='[cjsztdpbfvkgxmnlr]'. Funziona ma dà l'avvertimento warning: found = in conditional, should be ==.

Passa da un programma a una funzione (l'ho lasciato come programma perché, secondo la domanda, vince il "programma" più breve in byte.)

Riepilogo delle modifiche dal primo post

Revisione principale di regex / parte corrispondente.

La costante 72 è stata modificata in 69 in modo che il codice ASCII più basso nella stringa magica sia 10 anziché 13. Ciò consente di utilizzare una nuova riga letterale nella versione golfata anziché una sequenza di escape.

La stringa magica 'mzxcxkx'sostituisce le regole aritmetiche per i 5 caratteri proibiti nella tabella dei tipi CVCCV.

versione non golfata

aggiunto spazio bianco e cambiato newline in stringa magica in 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

Spiegazione della corrispondenza

I due caratteri nella stringa di input s[n,2]vengono confrontati con la coppia di caratteri del ciclo iterante. Se corrispondono e il modello regex di vocale consonante è corretto, i valori di riga e colonna i,jvengono verificati per la validità. Un attento ordinamento delle consonanti aiuta qui.

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

Per CCVCV

Una bitmap per ogni colonna della tabella sottostante è codificata nella stringa magica, dalla quale viene sottratto 69. Per tutte le colonne tranne le ultime due, sono richiesti solo 6 bit. Per gli ultimi due, i bit di ordine superiore devono essere 1, quindi viene generato un numero negativo (caratteri \ne :) per avere 1 iniziali anziché zero iniziali. Tuttavia, non vogliamo includere le ultime tre righe della tabella, quindi invece di spostare i diritti e ANDing per 1, spostiamo i diritti e AND per 1-j/14cui normalmente viene valutato 1, ma su 0 per le ultime 3 righe.

Il seguente programma (con le stesse espressioni dell'invio) è stato utilizzato per generare le tabelle seguenti (decommentare la ifriga richiesta per la tabella desiderata.

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 byte

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

Spiegazione

Restituisce un array contenente l'ultima lettera (verità) se è un gismu valido o nullse non lo è.

Gran parte delle dimensioni deriva dalle CCVCVcoppie codificate (anche dopo averle condensate). Potrebbe essere possibile trovare un modello per generarli, ma ho già passato troppo tempo su questo! 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 byte

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

Immagino che questo sia il mio lavoro adesso.