(Wörtlich: "Folgt / realisiert dies der Gismu-Form ?")

Prämisse

Die Sprache Lojban ist eine konstruierte Sprache , was teilweise bedeutet, dass alle ihre Wörter geschaffen wurden, anstatt sich auf natürliche Weise entwickeln zu dürfen. Die semantische Basis von Lojban sind seine Gismu oder Wurzelwörter, die durch die Kombination von Wurzeln aus weit verbreiteten natürlichen Sprachen wie Chinesisch, Hindi und Englisch synthetisiert wurden . Alle Gismu sind 5 Buchstaben lang und folgen einer bestimmten strengen Form.

Information

Für unsere Zwecke lautet das Lojban-Alphabet:

abcdefgijklmnoprstuvxz

Das heißt, das römische Alphabet ohne hqwy.

Dieses Alphabet kann in vier Kategorien unterteilt werden:

• Vokale aeiou

• Sonorante Konsonanten lmnr

• Stimmlose Konsonanten ptkfcsx. Wenn sie geäußert werden, werden diese jeweils die ...

• Stimmhafte Konsonanten bdgvjz(Kein stimmhafter Konsonant entspricht x.)

Um ein gültiges Gismu zu sein, muss eine 5 Zeichen lange Zeichenfolge:

1. Seien Sie in einem der Konsonant-Vokal-Muster CVCCVoder CCVCV, wobei C einen Konsonanten darstellt und V einen Vokal darstellt.

2. Befolgen Sie die Konsonanten-Matching-Regeln.

Konsonantenübereinstimmungsregeln für CCVCV-Wörter:

Die ersten beiden Zeichen müssen eines der folgenden 48 Paare ( Quelle ) bilden:

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

Beachten Sie, dass dies besser aussieht, wenn Sie es in stimmhafte und stimmlose Paare aufteilen. Insbesondere ist jedes stimmhafte Paar gültig, wenn das entsprechende stimmlose Paar gültig ist. Dies gilt nicht für Paare mit einem sonoranten Konsonanten. clist gültig aber jlnicht.

Konsonantenübereinstimmungsregeln für CVCCV-Wörter ( Quelle ):

Das dritte und vierte Zeichen müssen den folgenden Regeln entsprechen:

1. Es ist verboten, dass beide Konsonanten gleich sind [...]

2. Es ist verboten, dass ein Konsonant stimmlos und der andere stimmlos ist. Die Konsonanten "l", "m", "n" und "r" sind von dieser Einschränkung ausgenommen. Infolgedessen ist "bf" und "sd" verboten, aber sowohl "fl" als auch "vl" und "ls" und "lz" sind zulässig.

3. Es ist verboten, beide Konsonanten aus der Menge "c", "j", "s", "z" zu ziehen.

4. Die spezifischen Paare "cx", "kx", "xc", "xk" und "mz" sind verboten.

Beachten Sie, dass 179 mögliche Paare vorhanden sind.

Herausforderung

Bestimmen Sie, ob die angegebene Zeichenfolge den Regeln für die Gismu- Bildung entspricht. Das ist Code-Golf , also gewinnt die kürzeste Lösung in Bytes.

Eingabe : Eine Zeichenfolge der Länge 5 aus dem Lojban-Alphabet.

Ausgabe : Ein wahrer Wert, wenn der String ein Gismu sein kann ansonsten und ein Falsey-Wert sein kann.

Testfälle

Gültig:

gismu
cfipu
ranxi
mupno
rimge
zosxa

Ungültig:

ejram
xitot
dtpno
rcare
pxuja
cetvu

Weitere Testfälle: Diese Textdatei enthält alle gültigen gismu, eine pro Zeile.

_{Ich kenne Lojban nicht wirklich, daher vermute ich, dass die Titelübersetzung falsch ist. Hilfe wird geschätzt.}

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

Ein paar weitere Bytes könnten wie folgt gespeichert werden:

Mit zauf false initialisieren z=!c='[cjsztdpbfvkgxmnlr]'. Dies funktioniert, gibt aber die Warnung warning: found = in conditional, should be ==.

Wechsel von einem Programm zu einer Funktion (Ich habe es als Programm verlassen, weil laut Frage das kürzeste "Programm" in Bytes gewinnt.)

Zusammenfassung der Änderungen seit dem ersten Beitrag

Generalüberholung des Regex / Matching-Teils.

Die Konstante 72 wurde in 69 geändert, sodass der niedrigste ASCII-Code in der magischen Zeichenfolge 10 statt 13 ist. Dadurch kann in der Golf-Version anstelle einer Escape-Sequenz eine wörtliche Newline verwendet werden.

Die magische Zeichenfolge 'mzxcxkx'ersetzt die Rechenregeln für die 5 verbotenen Zeichen in der CVCCV-Typentabelle.

ungolfed version

Whitespace hinzugefügt und Newline in Magic String zu a geändert \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

Erklärung zum Matching

Die beiden Zeichen in der Eingabezeichenfolge s[n,2]werden mit dem Zeichenpaar der Iterationsschleife verglichen. Wenn sie übereinstimmen und das Konsonanten-Vokal-Regex-Muster korrekt ist, werden die Zeilen- und Spaltenwerte i,jauf Gültigkeit überprüft. Hier hilft eine sorgfältige Bestellung der Konsonanten.

Für 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.

Für CCVCV

Eine Bitmap für jede Spalte der folgenden Tabelle wird in die magische Zeichenfolge codiert, von der 69 subtrahiert werden. Für alle Spalten außer den letzten beiden sind nur 6 Bits erforderlich. Für die letzten beiden müssen die höherwertigen Bits 1 sein, daher wird eine negative Zahl (Zeichen \nund :) generiert, um führende Einsen anstelle führender Nullen zu erhalten. Wir möchten jedoch nicht die letzten drei Zeilen der Tabelle einschließen. Anstatt also Rechteverschiebung und UND-Verknüpfung um 1, werden Rechteverschiebung und UND-Verknüpfung 1-j/14normalerweise zu 1 ausgewertet, die letzten drei Zeilen jedoch zu 0.

Das folgende Programm (mit den gleichen Ausdrücken wie die Übermittlung) wurde verwendet, um die folgenden Tabellen zu generieren (kommentieren ifSie die für die gewünschte Tabelle erforderliche Zeile aus.

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

Erläuterung

Gibt ein Array mit dem letzten Buchstaben (wahr) zurück, wenn es ein gültiges Gismu ist oder nullnicht.

Ein Großteil der Größe stammt von den fest codierten CCVCVPaaren (auch nach deren Verdichtung). Es könnte möglich sein, ein Muster zu finden, um sie zu generieren, aber ich habe bereits viel zu viel Zeit damit verbracht! 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])

Prüfung

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

Ich denke, das ist jetzt meine Arbeit.