फ्लैग सेमीफोर एनकोडर

Question

आपका लक्ष्य एक फ्लैग सेमाफोर एनकोडर लिखना है , जो किसी दिए गए वाक्य को विकिपीडिया पर वर्णित सेमाफोर सिस्टम के अनुसार संबंधित फ्लैग सेमाफोर वर्णों में बदल देगा ।

मान लें कि इनपुट स्टड (या समतुल्य) के माध्यम से प्रदान किया गया एकल वाक्य है। आपके आउटपुट में सेमीफोर वर्णों की एक श्रृंखला होनी चाहिए, जिसमें प्रत्येक पंक्ति वाक्य से एक शब्द का प्रतिनिधित्व करती है। आपको केवल वर्णमाला (AZ) से निपटने की आवश्यकता है और अन्य सभी गैर-अंतरिक्ष वर्णों को अनदेखा करना चाहिए, लेकिन आपको अपरकेस और लोअरकेस दोनों को संभालने में सक्षम होना चाहिए। आपके आउटपुट में अतिरिक्त व्हाट्सएप को रखने की अनुमति है।

सेमाफोर वर्णों को 3x3 वर्ग के रूप में प्रदर्शित किया जाना चाहिए, Oमध्य में और ध्वज पदों को वर्णों द्वारा दर्शाया जाएगा | - / \। प्रत्येक सेमाफोर वर्ण को एक स्थान के निकटवर्ती वर्णों से अलग किया जाना चाहिए, और प्रत्येक पंक्ति को एक रिक्त रेखा से अलग किया जाना चाहिए। उन शब्दों के लिए रैपिंग के बारे में चिंता न करें जो आपके प्रदर्शन के लिए बहुत लंबे हो सकते हैं - यह दिखावा करें कि आपकी लाइनों में अनंत लंबाई है।

नमूना इनपुट:

abcdefg hijklmn opqrstu vwxyz

नमूना उत्पादन:

        \    |    /
 O  -O   O   O   O   O-  O
/|   |   |   |   |   |   |\

    \    |   |    /
-O   O   O-  O   O   O-  O
/   /       /   /   /   / \

\    |    /         \|  \ /
-O  -O  -O  -O- -O   O   O
                  \ 

 |    /   / \ 
 O   O-  O   O-  O-
  \       \       \

नमूना इनपुट:

This is Code Golf.

नमूना उत्पादन:

\|      \ 
 O  -O   O  -O 
    /   /     \

\      
 O  -O 
/     \

\   \    |    /
 O  -O   O   O 
 |       |   |

    \     /  
 O  -O   O   O-
 |\     /    |

चूंकि यह कोड-गोल्फ है , सबसे छोटा समाधान जीतता है।

Comments

kolmogorov- जटिलता ? यह मुझे लगता है कि मौलिक रूप से यह लुकअप टेबल को कंप्रेस करने के बारे में है।

— टेलर में पीटर टेलर

@Peter टेलर हाँ, उस टैग को जोड़ना शायद एक अच्छा विचार है। धन्यवाद।

— मिगिमारू

and each row must be separated by a blank line=> प्रत्येक शब्द का अर्थ है, है ना?

— उपयोगकर्ता अज्ञात

इससे पहले कि मैं इस पहेली को पढ़ूँ, मैंने गलती से सोचा कि इसे प्रोग्रामिंग अर्थ में सेमाफोरेस के साथ करना है। ¡Jajajajajja!

— थॉमस एडिंग

@user अज्ञात मैं सेमीफोर वर्णों की एक पंक्ति को संदर्भित करने के लिए वहां पंक्ति का उपयोग कर रहा था । शायद इसके बजाय शब्द का उपयोग करना बेहतर विकल्प होता।

— मिगिमारू

Answer 1

पर्ल, 282 264 251 247 245 243 241 240 236 233 229 227 220 218 216 214 वर्ण

$_=lc<>;map{y/a-z//cd;y/a-z/`HABDP\xc0(!\x12"$0\xa0\t\n\f\30\x88\3\5\x82\24\x84\21\x90/;@a=($/)x4;map{$s=ord;$a[$_/3].=substr" \\|/-O-/|\\",$_==4||$s>>$_-($_>4)&1?$_+1:0,1for 0..8;$_.=" "for@a}split//;print@a}split

कुछ प्रेटीफायिंग लाइन टूटने के साथ:

$_=lc<>;
map{
y/a-z//cd;
y/a-z/`HABDP\xc0(!\x12"$0\xa0\t\n\f\30\x88\3\5\x82\24\x84\21\x90/;
@a=($/)x4;
map{
$s=ord;
$a[$_/3].=substr" \\|/-O-/|\\",$_==4||$s>>$_-($_>4)&1?$_+1:0,1for 0..8;
$_.=" "for@a
}split//;
print@a}split

इस काम को करने में मुझे थोड़ा समय लगा है (एक पर्ल जवाब में मेरा पहला प्रयास)। यह बहुत सारे अन्य उत्तरों के समान विचार पर आधारित है। प्रत्येक ध्वज 8 में से एक स्थिति में हो सकता है, दो ध्वज हैं, और दो ध्वज कभी भी एक ही स्थिति में नहीं हो सकते। इसका मतलब है कि मैं एक बाइट में दोनों झंडे की स्थिति को सांकेतिक शब्दों में बदल सकता हूं - जिसका अर्थ यह भी है कि मैं पर्ल के y///फ़ंक्शन (ऑपरेटर?) का उपयोग करके किसी वर्ण से सीधे इसके एन्कोडिंग में अनुवाद कर सकता हूं । इसलिए:-

a = 01100000 96 = `
b = 01001000 72 = H
c = 01000001 65 = A
d = 01000010 66 = B
e = 01000100 68 = D
f = 01010000 80 = P
etc...

इसलिए:

y/a-z/`HABDP..../;

मैं कुछ ऐसे पात्रों से बच गया हूं जो प्रोग्राम की नकल और पेस्टिंग को आसान बनाने के लिए सामान्य उपयोग की गई सीमा से बाहर हैं - लेकिन मुझे पूरा यकीन है कि मैं भागने के कोड को बदलने के लिए एक प्रोग्राम लिख सकता हूं, जो मुझे खुद को बचाने वाले पात्रों के साथ है। लगभग 30 अक्षर।

Answer 2

पायथन, 244 238 233 232

e='abhioptuwycdjmnsqxzfgvklebr'
for w in raw_input().split():
 for i in 0,3,6,9:print' '.join(''.join((' '+'\|/-O-/|\ '[j])[`j`in'4'+'6736031025071568328578162735'[e.find(c):][:2]]for j in range(i,9)[:3])for c in w if c.lower()in e)

यह मेरा पसंदीदा चाल का उपयोग करता है: एकल ट्रैक एन्कोडिंग। मैंने सेमाफोर बिट्स (sbits) लेबल किया है

\|/     012
- -  -> 3 5
/|\     678

निम्नलिखित चिट्ठियाँ प्राप्त करने के लिए कौन से पत्र किस अक्षर के लिए होते हैं:

0: ciotuy
1: djkptv
2: elquwx
3: bhopqrs
5: fjmrwyz
6: ahiklmn
7: abcdefg
8: gnsvxz

प्रत्येक अक्षर चार्ट में ठीक दो बार होता है, क्योंकि सिग्नलमैन के पास दो हथियार होते हैं। फिर, मैं इसे अक्षर az पर एक ग्राफ के रूप में देखता हूं, साझा करने वाले अक्षरों के बीच किनारों के साथ, किनारों के साथ साझा किए गए किनारों के अनुसार लेबल किए गए किनारों के साथ। आदर्श रूप से, मुझे इस ग्राफ के माध्यम से एक हैमिल्टन पथ मिलेगा, जैसे कि बाद के किनारों में समान लेबल नहीं है। ऐसा कोई पथ मौजूद नहीं है ... इसलिए आप ध्यान देंगे कि चर eमें bदो बार अक्षर हैं ।

अपने लगभग-हैमिल्टन पथ के साथ e, मैं एक dलेबल की एक सारणी का निर्माण करता हूं जिसका उपयोग ट्रैवर्सल में किया जाता है e। फिर, यह पता लगाने के लिए कि उसे हथियार कहां रखना है, सिग्नलमैन को केवल निम्नलिखित आसान चार्ट में वांछित पत्र ढूंढना होगा

abhioptuwycdjmnsqxzfgvklebr
6736031025071568328578162735

उसके हाथ सीधे नीचे की स्थिति में, और नीचे और अक्षर के दाईं ओर जाते हैं।

Comments

मैं इस ideone पर चलाने के लिए जब तक मैं बदल नहीं मिल सका to_lower()करने के लिए lower()। इसके अलावा, जब मैंने इसे गैर-वर्णनात्मक इनपुट देने की कोशिश की तो यह एक त्रुटि थी।

— मिगिमारू

Answer 3

स्काला, 272 वर्ण

println(readLine.filter(c=>c.isLetter||c==' ').toLowerCase.split(" ").map{_.map(q=>("    O    "/:("^@a,6Tr?W*+5Sq9(2Pn%/-47MU"(q-'a')-27+""))((g,x)=>g.updated(x-'0',"\\|/-O-/|\\"(x-'0'))).grouped(3).toList).transpose.map(_.mkString(" ")).mkString("\n")}.mkString("\n\n"))

Ungolfed (अच्छी तरह से, कम-गोल्फ):

println(
  readLine.filter(c => c.isLetter || c==' ').
  toLowerCase.
  split(" ").
  map{ s =>
    val lookup = "^@a,6Tr?W*+5Sq9(2Pn%/-47MU".map(c => (c-27).toString)
    s.map(q =>
      ("    O    " /: lookup(q-'a')){(g,x) => 
        g.updated(x-'0', "\\|/-O-/|\\"(x-'0'))
      }.grouped(3).toList
    ).transpose.map(_.mkString(" ")).mkString("\n")
  }.mkString("\n\n")
)

Answer 4

रूबी, 287 अक्षर

gets.split.map{|w|puts (0..2).map{|l|w.chars.map{|c|(' '*576+'CAEAEADBCAF DAEBDACAAAI EAFADACAABG BAEAFEL A_ FACABADADAAG AAFBADQ AGX GAFADABAAAAF'.split.zip('\\|/-o-/|\\'.chars).map{|a,c|(a.chars.zip([' ',c]*9).map{|x,z|[z]*(x.ord-64)}.flatten)}.transpose*''*2)[c.ord*9+3*l,3]}*' '},''}

इनपुट STDIN पर दिया जाना चाहिए।

Answer 5

स्कैला 494 बिना न्यूलाइन्स 520 नईलाइन्स के साथ:

def k(i:Int,d:Int=0):(Int,Int)=if(i<(7-d))(d,i+1)else k(i-(7-d),d+1)
def t(i:Char)=(if(i=='y')i-4 else
if(i=='z')i+2 else
if(i=='j')i+14 else
if(i>='v')i+3 else
if(i>'i')i-1 else i)-'a'
def q(p:(Int,Int),i:Int,c:Char)=if(p._1==i||p._1+p._2==i)""+c else" "
def g(r:Int,c:Char)={val p=k(t(c.toLower))
print((r match{case 1=>q(p,3,'\\')+q(p,4,'|')+q(p,5,'/')
case 2=>q(p,2,'-')+"o"+q(p,6,'-')
case 3=>q(p,1,'/')+q(p,0,'|')+q(p,7,'\\')})+" ")}
for(w<-readLine.split(" ")){println;for(r<-(1 to 3)){w.map(c=>g(r,c));println}}

ungolfed:

def toClock (i: Int, depth: Int=0) : (Int, Int) = {
  if (i < (7 - depth)) (depth, i+1) else toClock (i - (7-depth), depth + 1)}

def toIdx (i: Char) = {
 (if (i == 'y') i - 4  else 
  if (i == 'z') i + 2  else 
  if (i == 'j') i + 14 else 
  if (i >= 'v') i + 3 else 
  if (i > 'i') i - 1 else i ) - 'a'}

def p2c (pair: (Int, Int), i: Int, c: Char) = {
 if (pair._1 == i || pair._1 + pair._2 == i) ""+c else " "
}

def printGrid (row: Int, c: Char) = {
  val idx = toIdx (c.toLower)
  val pair = toClock (idx)
  row match {
    case 1 => { print(
      p2c (pair, 3, '\\') + 
      p2c (pair, 4, '|') + 
      p2c (pair, 5, '/') + " ")
    }
    case 2 => { print(
      p2c (pair, 2, '-') + "o" + 
      p2c (pair, 6, '-') + " ")
    }
    case 3 => { print(
      p2c (pair, 1, '/') + 
      p2c (pair, 0, '|') + 
      p2c (pair, 7, '\\') + " ")
    }
  }
}

val worte = "This is Code Golf"
(1 to 3).map (row => {worte.map (c => printGrid (row, c));println})

स्पष्टीकरण:

मैंने एक घड़ी-पैटर्न का अवलोकन किया, लेकिन 12 घंटों के साथ नहीं, लेकिन 8. और स्टार्टटाइम 0 है, जहां 6 बजे हैं, और ए, बी, सी दक्षिण में पहले (एक) ध्वज के साथ पहले कोड हैं।

चूंकि ध्वज 1 और 2 अप्रभेद्य हैं, इसलिए हम पहले ध्वज के लिए कम संख्या के साथ सभी संयोजनों को क्रमबद्ध कर सकते हैं। दुर्भाग्य से, शुरुआत से ठीक क्रम परेशान है, जब j मैं i का पालन नहीं करता है, लेकिन k, l, m, और बाद में यह गड़बड़ हो जाता है।

इसलिए मैं मानचित्रण के लिए अपनी कुंजियों को फिर से व्यवस्थित करता हूं:

val iis = is.map {i => 
  if (i == 'y') i - 4  else 
  if (i == 'z') i + 2  else 
  if (i == 'j') i + 14 else 
  if (i >= 'v') i + 3 else 
  if (i > 'i') i - 1 else i }.map (_ - 'a')

iis.zipWithIndex .sortBy (_._1) .map (p => (p._1, ('a' + p._2).toChar))

Vector((97,a), (98, b), (99, c), (100,d), (101,e), (102,f), (103,g), 
      (104,h), (105,i), (106,k), (107,l), (108,m), (109,n), 
      (110,o), (111,p), (112,q), (113,r), (114,s), 
      (115,t), (116,u), (117,y), -------
      -------  (120,j), (121,v), 
      (122,w), (123,x), 
      (124,z))

यदि हम प्रत्येक वर्ण से 'a' को हटाते हैं, तो हमें संख्याएँ (0 से 7 + 6 + 5 + ... + 1) प्राप्त होती हैं। हम एक चरित्र-ग्रिड की संख्या को मैप कर सकते हैं

3 4 5   \ | /            |
2   6   - o -    - o   - o 
1 0 7   / | \    (2, ) (2,2)

दो नंबरों की एक जोड़ी दो झंडे दिखा सकती है, जहां पहला नंबर पहले झंडे के लिए 0 से 6 का सूचकांक है, और दूसरे झंडे में दूसरे झंडे के लिए 1 से 7 तक संख्या नहीं है, लेकिन दूरी से दूरी के लिए पहले दूसरे झंडे के लिए। (2,2) का अर्थ होगा, पहला ध्वज WEST है, और दूसरा वहाँ से उत्तर दिशा में दो कदम दक्षिणावर्त है।

def toClock (i: Int, depth: Int=0) : (Int, Int) = {
  if (i < (7 - depth)) (depth, i+1) else toClock (i - (7-depth), depth + 1)}

Vector( (0,1), (0,2), (0,3), (0,4), (0,5), (0,6), (0,7), 
    (1,1), (1,2), (1,3), (1,4), (1,5), (1,6), 
    (2,1), (2,2), (2,3), (2,4), (2,5), 
    (3,1), (3,2), (3,3), 
           (4,2), (4,3), 
    (5,1), (5,2), 
    (6,1))

Comments

मुझे स्काला के बारे में ज्यादा जानकारी नहीं है। क्या कोई तरीका है जिससे मैं इसे आइडोन पर परख सकता हूं? मैंने इसे एक object Main extends Applicationब्लॉक में लपेटने की कोशिश की , लेकिन यह पर्याप्त नहीं लगता है।

— मिगिमारू

IDEONE को एक वर्ग की आवश्यकता है जिसका नाम है Main, अगर मुझे सही तरीके से याद है, तो एक मुख्य विधि, शायद एप्लिकेशन (-2.8) के बजाय App (scala-2.9 के लिए) का विस्तार करना चाहिए - और क्या यह स्टड से पढ़ा जाता है? में simplyscala आप और अधिक बस कोड का परीक्षण कर सकते हैं। यदि आप इसके readLineसाथ अंतिम पंक्ति में प्रतिस्थापित "readLine"करते हैं तो यह काम करना चाहिए (कोड 2.8 संगत है)।

— उपयोगकर्ता अज्ञात

धन्यवाद! मैं सिम्पलसेला के बारे में नहीं जानता था, इससे चीजें बहुत आसान हो जाती हैं।

— मिग्मारू

यदि आपको फिर से लिंक की आवश्यकता है: मैंने पहले से ही मेटा में लिंक कहीं डाल दिया है, जहां ऐसी चीजें एकत्र की जाती हैं।

— उपयोगकर्ता अज्ञात

क्या यह अपरकेस संभालता है?

— थॉमस ईडिंग सेप 3'11

Answer 6

हास्केल 331 357 339 अक्षर

golfed:

import Data.Char
t[x,y]=q[x,mod(y+1)8]
q z@[x,y]|x==y=[x+1,y+2]|0<1=z
x%y=[x,y]
c 65=0%1
c 74=6%4
c 75=1%4
c 79=2%3
c 84=3%4
c 86=4%7
c 87=5%6
c 89=3%6
c 90=6%7
c x=t$c$pred x
_!9='O'
c!n|n`elem`c="|/-\\"!!mod n 4|0<1=' '
s x=do n<-[3:4%5,2:9%6,1:0%7];'\n':do c<-x;' ':map(c!)n
main=putStr.s.map(c.ord.toUpper)=<<getLine

Ungolfed:

type Clock = [Int]

tick :: Clock -> Clock
tick [h, m] = tick' [h, mod (m + 1) 8]

tick' :: Clock -> Clock
tick' [h, m]
  | h == m = [h + 1, m + 2]
  | otherwise = [h, m]

clock :: Char -> Clock
clock 'a' = [0,1]
clock 'j' = [6,4]
clock 'k' = [1,4]
clock 'o' = [2,3]
clock 't' = [3,4]
clock 'v' = [4,7]
clock 'w' = [5,6]
clock 'y' = [3,6]
clock 'z' = [6,7]
clock c = tick $ clock $ pred c

arm :: Int -> Char
arm 0 = '|'
arm 1 = '/'
arm 2 = '-'
arm 3 = '\\'

drawAt :: Clock -> Int -> Char
drawAt _ 9 = 'O'
drawAt c n = if n `elem` c
  then arm $ n `mod` 4
  else ' '

-- showClock is not in golfed code. Just there for debugging.
showClock :: Clock -> String
showClock c = unlines $ map (map $ drawAt c) [
    [3,4,5]
  , [2,9,6]
  , [1,0,7]
  ]

showClocks :: [Clock] -> String
showClocks cs = unlines $ map (showClocks' cs) [[3,4,5],[2,9,6],[1,0,7]]

showClocks' :: [Clock] -> [Int] -> String
showClocks' cs ns = cs >>= \c -> ' ' : map (drawAt c)

mainx :: IO ()
mainx = putStr . showClocks . map clock =<< getLine

---

345    \|/                                     \                      
2 6 == -O-          -O          tick  -O   ==   O      tick   O   ==  -O
107    /|\          /                 /        /              |\      /
             [1,2] or [2,1]    tick [1,2] == [1,3]     tick [0,7] == [1,2]

एन्कोडिंग वह [hour, minute]जगह है जहां घड़ियों में 8 घंटे और 8 मिनट होते हैं। मिनट घंटे से ज्यादा तेज चलते हैं। यदि एक घड़ी टिक जाती है, जहां घंटे और मिनट बराबर होंगे, तो 1 घंटे और 2 मिनट के लिए भी जोड़ें (दूसरा टिक उदाहरण देखें)। यही एकमात्र तरीका है घंटे वृद्धि। जब मिनट कुछ अनियंत्रित मिनट तक पहुँचते हैं तो घंटे नहीं बढ़ते हैं। केवल जब मिनटों के बराबर घंटे होंगे। अनगॉल्ड कोड में, clockअक्षरों को घड़ियों में बदल देता है जो सेमीफ़ोर का प्रतिनिधित्व करते हैं। ज्यादातर घड़ियां पिछले वाले से टिक के आधार पर बनाई जाती हैं। बाकी हार्ड कोडेड हैं। कोड के लिए वास्तव में अधिक कुछ नहीं है।

Answer 7

पर्ल, 356 , 275 वर्ण

बड़ी संख्या में वर्णों को 'यदि और' को 'से बदलकर बचाया गया था? : 'निर्माण।

@_=split('', $ARGV[0]);for (@_){print eval{/[ciotuy]/ ?'\\':' '}.eval{/[djkptv]/ ?'|':' '}.eval{/[elquwx]/ ?'/':' '}."\n".eval{/[bhopqrs]/ ?'-':' '}."0".eval{/[fjmrwyz]/ ?'-':' '}."\n".eval{/[ahiklmn]/ ?'/':' '}.eval{/[abcdefg ]/ ?'|':' '}.eval{/[gnsvxz]/ ?'\\':' '."\n"};}

Comments

आपका कोड केवल निचले अक्षरों के लिए काम करने लगता है। यदि आप <>इसके बजाय उपयोग करते हैं $ARGV[0]तो आप स्टडिन से इनपुट ले सकते हैं और lcसभी वर्णों को निम्न स्थिति में बदलने के लिए उपयोग कर सकते हैं । यह आपको 4 वर्णों को बचाने का अतिरिक्त लाभ है। यह गैर-वर्णमाला वर्णों को भी नहीं संभालता है, लेकिन यकीनन You only need to deal with the alphabet (A-Z) and should ignore all other non-space charactersउनके साथ क्या करना है, इस पर बहुत स्पष्ट नहीं है ...

— गैरेथ

मैं अभी कोड का परीक्षण करने में सक्षम नहीं हूं, लेकिन यह ऐसा लगता है कि कोड केवल गैर-अल्फा वर्णों के लिए रिक्त स्थान प्रिंट करता है, जो ठीक है।

— मिग्मारू

@migimaru I`ll इसे सही करने की कोशिश करेंगे।

— ज़ुरा

गैर-वर्णमाला वर्णों के लिए @ ज़ुरा मुद्रण स्थान स्वीकार्य है। आपको इसे ठीक करने की आवश्यकता नहीं है।

— मिग्मारू

Answer 8

पॉवरशेल , 198 192 191 188 बाइट्स

-split$args|%{$s=$_
"\|/ ciotuy djkptv elquwx","-O- bho-s ^ fjmrwyz","/|\ ahik-n a-g gnsvxz"|%{$f,$p=-split$_
($s|% t*y|%{$c=$_
-join(&{$p|%{" $f"[++$i*($c-match"[$_ ]")]}})})-join' '}
''}

इसे ऑनलाइन आज़माएं!

आउटपुट में एक पूंछ खाली लाइन होती है।

कम गोल्फ वाला:

-split$args|%{
    $string=$_
    "\|/ ciotuy djkptv elquwx",
    "-O- bho-s ^ fjmrwyz",
    "/|\ ahik-n a-g gnsvxz"|%{
        $flags,$patterns=-split$_
        $row=$string|% toCharArray|%{
            $char=$_
            $semaphoreRow=&{   # call the scriptblock in a new scope to reinit $i
                $patterns|%{
                    " $flags"[++$i*($char-match"[$_ ]")]  # return a flag symbol
                }
            }
            -join($semaphoreRow)
        }
        $row-join' '
    }
    ''
}

Answer 9

चारकोल , 70 बाइट्स

Ｆ⪪↧Ｓ «Ｆι«Ｆ⪪”↶↖→∧gτ→|⮌!⧴KD✂‖5»⊞H⭆K↧ⅉ＆$↥x-#↖x9｜²λＰe⁸” «Ｐ⊗№λκ↷¹»oＭ³→»⸿Ｍ³↓

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆ⪪↧Ｓ «

रिक्त स्थान पर दिए गए इनपुट को विभाजित करें और प्रत्येक शब्द पर लूप करें।

Ｆι«

प्रत्येक वर्ण पर पाश।

Ｆ⪪”↶↖→∧gτ→|⮌!⧴KD✂‖5»⊞H⭆K↧ⅉ＆$↥x-#↖x9｜²λＰe⁸” «

fjmrwyz gnsvxz abcdefg ahiklmn bhopqrs ciotuy djkptv elquwxप्रत्येक अक्षर समूह पर रिक्त स्थान और लूप पर संकुचित स्ट्रिंग को विभाजित करें ।

Ｐ⊗№λκ

यदि समूह में वर्तमान अक्षर है तो वर्तमान दिशा में एक रेखा खींचें।

↷¹»

45 ° दक्षिणावर्त घुमाएँ।

oＭ³→»

केंद्र को आउटपुट करें oऔर अगले पत्र की स्थिति पर जाएं।

⸿Ｍ³↓

अगले शब्द की शुरुआत में जाएं।