Personnages

Appelons ces caractères Unicode consonnes IPA anglaises :

bdfhjklmnprstvwzðŋɡʃʒθ

Et appelons ces caractères Unicode les voyelles anglaises IPA :

aeiouæɑɔəɛɜɪʊʌː

(Oui, ːc'est juste la longue marque de voyelle, mais traitez-la comme une voyelle aux fins de ce défi.)

Enfin, ce sont des marques de stress primaires et secondaires :

ˈˌ

Notez que ɡ( U + 0261 ) n'est pas un g minuscule et que le marqueur de contrainte principal ˈ( U + 02C8 ) n'est pas une apostrophe et que ː( U + 02D0 ) n'est pas un deux-points.

Ta tâche

Étant donné un mot, empilez les voyelles au-dessus des consonnes qu'elles suivent et placez les marqueurs de stress sous les consonnes qu'elles précèdent. (Comme l'indique le titre de la question, un tel système d'écriture, où les séquences de voyelles consonantiques sont regroupées en tant qu'unité, est appelé abugida .) Étant donné l'entrée ˈbætəlʃɪp, produisez la sortie:

æə ɪ
btlʃp
ˈ

Un mot est garanti être une chaîne de consonnes, voyelles et marques de stress, comme défini ci-dessus. Il n'y aura jamais de marques de stress consécutives et elles seront toujours placées au début du mot et / ou devant une consonne.

Cas de test

Il peut y avoir des voyelles consécutives. Par exemple, kənˌɡrætjʊˈleɪʃəndevient

      ɪ
ə  æ ʊeə
knɡrtjlʃn
  ˌ   ˈ

Si un mot commence par une voyelle, imprimez-le sur la «ligne de base» avec les consonnes: əˈpiːldevient

 ː
 i
əpl
 ˈ

Un cas de test avec une voyelle initiale, stressée: ˈælbəˌtrɔsdevient

  ə ɔ 
ælbtrs
ˈ  ˌ  

Un long mot: ˌsuːpərˌkaləˌfrædʒəˌlɪstɪˌkɛkspiːæləˈdoʊʃəsdevient

               æ    
ː              ː ʊ  
uə aə æ əɪ ɪɛ  iəoə 
sprklfrdʒlstkkspldʃs
ˌ  ˌ ˌ   ˌ  ˌ    ˈ  

Un exemple absurde avec une diphtongue initiale, beaucoup d'empilement de voyelles et aucun marqueur de stress: eɪbaeioubaabaaadevient

 u
 o
 i a
 eaa
ɪaaa
ebbb

Implémentation de référence

Votre programme devrait produire la même sortie que ce script Python:

consonants = 'bdfhjklmnprstvwzðŋɡʃʒθ'
vowels = 'aeiouæɑɔəɛɜɪʊʌː'
stress_marks = 'ˈˌ'

def abugidafy(word):
    tiles = dict()
    x = y = 0

    is_first = True
    for c in word:
        if c in stress_marks:
            tiles[x + 1, 1] = c
        elif c in consonants or is_first:
            y = 0
            x += 1
            tiles[x, y] = c
            is_first = False
        elif c in vowels:
            y -= 1
            tiles[x, y] = c
            is_first = False
        else:
            raise ValueError('Not an IPA character: ' + c)

    xs = [x for (x, y) in tiles.keys()]
    ys = [y for (x, y) in tiles.keys()]
    xmin, xmax = min(xs), max(xs)
    ymin, ymax = min(ys), max(ys)

    lines = []
    for y in range(ymin, ymax + 1):
        line = [tiles.get((x, y), ' ') for x in range(xmin, xmax + 1)]
        lines.append(''.join(line))
    return '\n'.join(lines)

print(abugidafy(input()))

Essayez-le sur Ideone.

Règles

• Vous pouvez écrire une fonction ou un programme complet.

• Si votre programme a un type de chaîne / caractère Unicode, vous pouvez supposer que les entrées et les sorties les utilisent. Sinon, ou si vous lisez / écrivez depuis STDIN, utilisez l'encodage UTF-8.

• Vous pouvez produire une chaîne contenant des sauts de ligne, ou une liste de chaînes représentant des lignes, ou un tableau de caractères Unicode.

• Chaque ligne de sortie peut contenir n'importe quelle quantité d'espaces de fin. Si vous produisez une chaîne, elle peut avoir une seule nouvelle ligne de fin.

• Votre programme doit produire la sortie correcte pour les mots arbitrairement longs avec des chaînes de voyelles arbitrairement longues, mais peut supposer que le mot d'entrée est toujours valide.

• S'il n'y a pas de marqueurs de contrainte, votre sortie peut éventuellement inclure une dernière ligne vide (ne contenant rien ou des espaces).

• La réponse la plus courte (en octets) l'emporte.

NARS2000 APL, 138 octets

⍉⌽⊃E,⍨¨↓∘' '¨∨/¨∊∘M¨E←(1+(W∊M←'ˌˈ')++\W∊'bdfhjklmnprstvwzðŋɡʃʒθ')⊂W←⍞

Python, 222 octets

(202 caractères)

import re
def f(s):y=[w[0]in'ˈˌ'and w or' '+w for w in re.split('([ˈˌ]?[bdfhjklmnprstvwzðŋɡʃʒθ]?[aeiouæɑɔəɛɜɪʊʌː]*)',s)[1::2]];return[[x[i-1:i]or' 'for x in y]for i in range(max(len(w)for w in y),0,-1)]

Renvoie un tableau de caractères Unicode avec un tableau pour chaque ligne (contenant des espaces simples pour chaque espace requis)

Je ne sais pas encore où on peut obtenir une sortie décente en ligne (et je n'ai même pas les outils pour le tester correctement ici non plus).
J'ai chargé une version sur ideone qui utilise simplement les consonnes et les voyelles anglaises avec ,et .comme marques de stress, où j'ai truqué les cas de test pour se conformer.

JavaScript (ES6), 181 octets

f=
s=>(a=s.match(/[ˈˌ]?.[aeiouæɑɔəɛɜɪʊʌː]*/g).map(s=>/[ˈˌ]/.test(s)?s:` `+s)).map(s=>(l=s.length)>m&&(t=s,m=l),m=0)&&[...t].map(_=>a.map(s=>s[m]||` `,--m).join``).join`
`
;

<input oninput=o.textContent=f(this.value)><pre id=o>