शतरंज में, फोर्सिथ-एडवर्ड्स संकेतन , जिसे आमतौर पर "एफईएन" कहा जाता है, बोर्डों को ट्रांसक्रिप्ट करने का एक टेक्स्ट तरीका है। यह व्हाइट के दृष्टिकोण से ऊपर से नीचे तक बोर्ड की आठ पंक्तियों (शतरंज में "रैंक" कहा जाता है) में से प्रत्येक का वर्णन करता है। टुकड़ों को के (राजा), क्यू (रानी), आर (किश्ती), बी (बिशप), एन (नाइट), और पी (प्यादा) के रूप में लिखा जाता है। काले टुकड़े निचले अक्षरों में इन अक्षरों का उपयोग करते हैं, और सफेद टुकड़े बड़े अक्षरों में इन अक्षरों का उपयोग करते हैं। रिक्त स्थान 1 से 8 तक की संख्या से संकेत मिलता है कि कितने खाली स्थान हैं। एक पूरी तरह से खाली रैंक होगी 8, सबसे दाहिने कॉलम में एक सिंगल ब्लैक रूक (जिसे शतरंज में "फाइलें" कहा जाता है) होगा 7r, और एक पंक्ति के प्रत्येक छोर पर दो सफेद पंजे होंगे PP4PP। रैंकों को एक से अलग किया जाता है/। वहाँ आम तौर पर अन्य जानकारी कहा, यह दर्शाता है जो पक्ष, ले जाने के कैसलिंग और करने के लिए है है passant एन अधिकार, इस कदम संख्या, और halfmove घड़ी, लेकिन हम उन्हें इस चुनौती के प्रयोजनों के लिए ध्यान नहीं देगा।

इनपुट

जैसा कि आप कृपया कमांड लाइन या STDIN से एक FEN स्ट्रिंग। आप मान सकते हैं कि यह स्ट्रिंग हमेशा मान्य है।

उत्पादन

बोर्ड के एक साधारण ASCII कला प्रतिनिधित्व के बारे में लिखें क्योंकि यह वास्तव में दिखाई देगा:

टुकड़ों को एफईएन में उनके चरित्र द्वारा दर्शाया जाता है
रिक्त वर्ग रिक्त स्थान द्वारा दर्शाए जाते हैं
टुकड़ों और वर्गों को एक पाइप द्वारा अलग किया जाता है |और बोर्ड के प्रत्येक तरफ पाइप होते हैं

तो एक खाली बोर्ड, जैसा 8/8/8/8/8/8/8/8कि एफईएन में लिखा गया है, दिखाई देगा

| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |

एक शतरंज के खेल की प्रारंभिक स्थिति इस प्रकार लिखी जाती है rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR, और इस तरह दिखाई देगी

|r|n|b|q|k|b|n|r|
|p|p|p|p|p|p|p|p|
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
| | | | | | | | |
|P|P|P|P|P|P|P|P|
|R|N|B|Q|K|B|N|R|

शतरंज समुदाय में "द इम्मोर्टल गेम" कहे जाने वाले एंडरसेन-केसेरित्ज़की 1851 की अंतिम स्थिति के रूप में लिखा गया है r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1, और आपके कार्यक्रम को जब इनपुट प्राप्त होगा, तो यह आउटपुट होगा:

|r| |b|k| | | |r|
|p| | |p|B|p|N|p|
|n| | | | |n| | |
| |p| |N|P| | |P|
| | | | | | |P| |
| | | |P| | | | |
|P| |P| |K| | | |
|q| | | | | |b| |

— प्रतीक
स्रोत

क्या ऐसा फ़ंक्शन लिखना स्वीकार्य है जो इनपुट और रिटर्न आउटपुट लेता है, बल्कि इसे STDOUT में लिखने के बजाय?

— निधि मोनिका का मुकदमा

@QPaysTaxes डिफ़ॉल्ट रूप से हम इसे अनुमति देते हैं और वास्तव में कई समाधान पहले से ही ऐसा करते हैं। अंततः यह ओपी पर निर्भर है, हालांकि इस मामले में हमारी चूक को ओवरराइड करना अनावश्यक लगता है।

— एलेक्स ए।

2

आपके द्वारा स्वीकार किया गया उत्तर सबसे छोटा नहीं है। गोल्फ भाषाओं के प्रति आपकी भावनाओं के बावजूद, कोड गोल्फ का अर्थ है कि सबसे छोटा कोड जीतता है।

— डेनिस

3

आप उन्हें दंड भी नहीं दे सकते हैं या एक मनमाना जवाब स्वीकार नहीं कर सकते हैं । पूरी साइट उद्देश्य जीतने के मानदंड के आसपास बनाई गई है।

— डेनिस

1

+1एक दिलचस्प चुनौती के लिए। बिना किसी अच्छे कारण-2 के गलत उत्तर को स्वीकार करने के लिए

— जेम्स

9

पर्ल, 28 बाइट्स

के लिए +2 शामिल है -lp

STDIN पर इनपुट दें

fen.pl <<< "r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1"

fen.pl:

#!/usr/bin/perl -lp
s/\d/$"x$&/eg;s/|/|/g;y;/;

दरअसल कुछ गोल्फिंग भाषाओं की लीग में ...

ध्यान दें कि फ़ाइल आधारित संस्करण को फ़ाइल में अंतिम न्यूलाइन की आवश्यकता है ताकि एक वास्तव में 29 बाइट्स हो। लेकिन कमांडलाइन संस्करण को अतिरिक्त नई लाइन की आवश्यकता नहीं है और इसलिए कोड 28 बाइट्स के रूप में गिना जाता है:

perl -lpe 's/\d/$"x$&/eg;s/|/|/g;y;/;' <<< "r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1"

— टन हास्पेल
स्रोत

1

गुमशुदा शेबंग?

— user253751

15

रेटिना, 13 बाइट्स

\d
$* 
/
¶

|

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

व्याख्या

पहला भाग (अनुगामी स्थान पर ध्यान दें):

\d
$*

रिक्त स्थान की विशिष्ट संख्या में कनवर्ट करने के लिए है। रेटिना में $*दोहराने की सुविधा होती है। जिस तरह से यह काम करता है: <num>$*<char>यदि कोई नहीं है <num>, तो रेटिना मान जाएगा $&या मिलान स्ट्रिंग, इस मामले में मिलान संख्या।

अगला भाग:

/
¶

बहुत आसान है, यह सब के /साथ बदल देता है ¶जो एक नई रेखा है।

अंतिम भाग समान काम करता है:

यह सब कुछ बदल देगा (इसलिए पहली पंक्ति में कुछ भी क्यों नहीं है) |। |हर जगह लगाना ।

— Downgoat
स्रोत

1

आप इसे S`/दूसरे चरण के साथ एक ही बाइट की गिनती के लिए ASCII में भी कर सकते हैं ।

— मार्टिन एंडर

12

रूबी - 75 82 78 76 75 62 59 58 57 56 बाइट्स

->n{"|#{n.gsub(/\d|
/){' '*$&.hex}.chars*?|}|".tr'/',$/}

वेंटरो के लिए धन्यवाद कुछ बाइट्स सहेजे गए

मुझे समझाने ( \nशाब्दिक नई पंक्ति की जगह के साथ ):

->n{"...".tr'/',$/}

यह स्पष्ट रूप से स्ट्रिंग का मान लौटाता है, प्रत्येक /को एक नई लाइन के साथ प्रतिस्थापित किया जाता है (डिफ़ॉल्ट रूप से, $/एक नई पंक्ति होती है)

"|#{...}|"

यह सुपर सरल है; यह सिर्फ एक पाइप, स्ट्रिंग प्रक्षेप, और एक अन्य पाइप युक्त एक स्ट्रिंग है। स्ट्रिंग प्रक्षेप का मूल्यांकन किया जाता है

n.gsub(/\d|\n/){' '*$&.hex}...

यह हर नंबर को कई स्पेस के साथ बदल देता है। मैं यहाँ कुछ नई खोज करके कुछ बाइट्स बचा सकता हूँ; क्योंकि hexरिटर्न 0 है, अगर स्ट्रिंग एक वैध संख्या नहीं है, जब यह एक नई लाइन पाता है - यानी के परिणाम के अंत में एक gets- यह इसे 0-लंबाई स्ट्रिंग के साथ बदल देता है, प्रभावी रूप से इसे हटा रहा है। इसके बिना, एक अनुगामी पाइप होगा।

$&एक मैजिक वैरिएबल है, जो लेटेस्ट वैरिएबल मैच के संपूर्ण टेक्स्ट को दर्शाता है, जो मुझे एक बाइट को खत्म करने से बचाता है |d|। मैं .hexइसके बजाय का उपयोग करके एक और बाइट बचा सकता हूं .to_i, जो काम करता है क्योंकि प्रत्येक संख्या 9 से कम है, जिसका मतलब है कि हेक्स और दशमलव में समान मूल्य हैं।

.chars*?|

यह हर चरित्र के बीच एक पाइप डालता है। ध्यान दें कि यह वह है जो पाइप को लाइनों के दोनों ओर (पहले और अंतिम को छोड़कर) डालता है क्योंकि स्लैश, जो अंततः trवर्णों के रूप में नई के रूप में बदल जाते हैं, और इसलिए पाइप से घिरे होते हैं। ?|बस का अर्थ है "एक चरित्र स्ट्रिंग "|""।

और बस। यह एक स्पष्ट रूप से निंदनीय सरल कार्यक्रम है। यह सिर्फ बहुत ही डरपोक वाक्यविन्यास चाल का उपयोग करता है।

— निधि मोनिका का मुकदमा
स्रोत

2

आप कुछ सरल चालें लागू करके 4 और पात्रों को बचा सकते हैं: puts"|#{gets.gsub(/\d|\n/){' '*$&.hex}.chars*?|}|".split'/'(बेशक, \nफिर से एक शाब्दिक नई रेखा के साथ बदलें )।

— वेंटरो

5

पायथ - 24 22 21 बाइट्स

.i*\|72jcu:G`H*Hd9z\/

टेस्ट सूट ।

+                     Concatenate
 K\|                  Store "|" in K and use value
+         K           Concatenate to end
 jK                   Join string by K, this puts "|" between each char
  :                   String substitution
        \/            Replace "/"
         b            With newline
   u                  Reduce
        9             Over [0, 9)
         z            With input as base case
    :G                String substitution current val
     `H               Replace stringifyed int from list we're looping through
     *Hd              With " "*that int

— Maltysen
स्रोत

4

पायथ, 23 बाइट्स

VT=:Q`N*dN;jc.i*\|72Q\/

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

यह काम किस प्रकार करता है:

VT=:Q`N*dN;jc.i*\|72Q\/
VT        ;                for N in range(10):
  =:Q`N*dN                     Q = Q.replace(`N`,repeat(' ',N))
             .i*\|72Q      temp = interweave(repeat('|',72), Q)
            c        \/    temp = chop(temp,'/')
           j               temp = join(temp,'\n')
                           print temp

— लीक नन
स्रोत

4

जावास्क्रिप्ट ईएस 7, 80 70 बाइट्स

एक अनाम फ़ंक्शन है जो इनपुट के रूप में एक स्ट्रिंग को स्वीकार करता है।

a=>[,...[+t?" ".repeat(t):t<"0"?`
`:t for(t of a)].join``,`
`].join`|`

80-बाइट ES6- केवल एप्राओच।

a=>a.split`/`.map(x=>[,...x.replace(/\d/g,t=>" ".repeat(t)),`
`].join`|`).join``

व्याख्या

हम सूची पर लूप के लिए एक सरणी समझ का उपयोग करते हैं:

[+t?" ".repeat(t):t<"0"?`
`:t for(t of a)]

यह इसके बराबर है:

[!isNaN(parseInt(t, 10)) ? " ".repeat(parseInt(t, 10)) : t === "/" ? "\n" : t for(t of a)]

यदि यह एक संख्या है, तो हमारे पास रिक्त स्थान की संख्या है। यदि यह है /, तो हमारे पास एक नई पंक्ति है। अन्यथा, हमारे पास चरित्र है। फिर, हम एक स्ट्रिंग बनाने के लिए कुछ भी नहीं के साथ समझ में शामिल होते हैं।

फिर, हम लंबाई 3 की एक सरणी बनाते हैं [,...that,"\n"]। ...छप में शामिल समझ को छींटे। इस में शामिल होने से परिणाम मिलता है।

— कोनोर ओ ब्रायन
स्रोत

क्या आपका मतलब ES6 नहीं है? ES7 बाहर नहीं है अभी तक मुझे विश्वास है।

— ericw31415

@ ericw31415 यह बाहर नहीं है, आप सही हैं, लेकिन कुछ ब्राउज़रों ने ES7 कल्पना के भाग को लागू करना शुरू कर दिया है।

— कॉनर ओ'ब्रायन

ओह ठीक। लेकिन फिर भी आपका कोड ES7 सुविधाओं में से किसी का भी उपयोग नहीं करता है, है ना?

— ericw31415

1

@ ericw31415 दरअसल, यह करता है। सरणी समझ ( [x for(x of a)]) ES7 हैं।

— कॉनर ओ'ब्रायन

कल्पना से हटाए नहीं गए थे

— एमडीएन का

3

जूलिया, 62 बाइट्स

s->split("|"join(replace(s,r"\d",d->" "^parse(d)),"|")"|","/")

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और स्ट्रिंग की एक सरणी देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

दृष्टिकोण QPaysTaxes के चालाक रूबी के उत्तर के समान है । हम प्रत्येक अंक को इनपुट में उस स्थान के साथ बदलते हैं, |जो प्रत्येक वर्ण के बीच में होता है, |सामने और पीछे की तरफ से होता है, और एक सरणी में विभाजित होता है /।

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

— एलेक्स ए।
स्रोत

Yay I ने चीजों को प्रेरित किया: D

— फंड मोनिका का मुकदमा

@QPaysTaxes आपने वास्तव में किया था। अच्छा समाधान!

— एलेक्स ए।

2

05AB1E , 21 बाइट्स

कोड:

9GNNð×:}S'|ý"|ÿ|"'/¶:

इसके अलावा 21 बाइट्स '|¹9GNNð×:}S'|«JJ'/¶::।

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 69 67 62 बाइट्स

s=>[,...s.replace(/[/-8]/g,c=>+c?' '.repeat(c):`
`),,].join`|`

अतिरिक्त कॉमा बाहरी विभाजन में खाली मान पैदा करते हैं जो शुरुआत और अंत |पात्रों का निर्माण करते हैं। आपको दो अनुगामी अल्पविरामों की आवश्यकता है क्योंकि अनुगामी अल्पविराम सूचियों के अंत में वैकल्पिक हैं, इसलिए पहला वाला अभी भी पिछले आइटम का हिस्सा है।

संपादित करें: @ user81655 के लिए 5 बाइट्स धन्यवाद सहेजे गए।

— नील
स्रोत

चाहेंगे /[\d/]/g,c=>+c?` `.repeat(c):`\n`काम करते हैं?

— user81655

1

@ user81655 धन्यवाद, लेकिन मुझे आपका इमोटिकॉन पसंद नहीं आया, इसलिए मैंने इसे एक नाराज चेहरे को चश्मे से बदल दिया।

— नील

1

रेटिना , 50 45 बाइट्स

यह मजेदार हाहा था। न केवल मैं रेटिना में एक नॉब हूं, बल्कि सामान्य रूप से रेगेक्स में भी ... यह शायद बहुत अधिक गोल्फ हो सकता है , इसलिए मैं कुछ और शोध करूंगा।

कोड:

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

— अदनान
स्रोत

$*कार्यक्षमता का उपयोग करने का प्रयास करें :)

— लीक

1

जोल्फ, 28 बाइट्स

RΜGi'/dΆγ'|RGρH«\d»d*♣PHEγγS

♣चरित्र के साथ बदलें \x05, या इसे यहां आज़माएं!

— कोनोर ओ ब्रायन
स्रोत

1

पायथन 3.5, 112 बाइट्स:

def r(o):print(''.join(['| '*8if h=='8'else'| '*int(h)if h.isdigit()else'|\n'if h=='/'else'|'+h for h in o])+'|')

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

— आर। कप
स्रोत

1

सी, 252 बाइट्स

i=-1,j,s=1,x;C(char*n){while(n[++i])s+=isdigit(n[i])?n[i]*2+1:2;char*m=(char*)malloc(s);for(i=j=-1;n[++i]&(m[++j]='|');)if(n[i]=='/')m[++j]='\n';else if(isdigit(n[i]))for(x=n[i]-'0';x;--x&&(m[++j]='|'))m[++j]=' ';else m[++j]=n[i];m[++j]='\0';return m;}

विस्तृत ऑनलाइन प्रयास करें

// input-string, input-string-size
char* C(char*n)
{
    int i=-1,j,s=1,x;

    // figure out required grid size
    while(n[++i])s+=isdigit(n[i])?n[i]*2+1:2;
    char*m=(char*)malloc(s);

    i=j=-1;
    while(n[++i]) // while not end of string
    {
        m[++j]='|'; // seperator

        if (n[i]=='/') // end of row
            m[++j]='\n';
        else if (isdigit(n[i])) // fill spaces
            for(x=n[i]-'0';x;--x&&(m[++j]='|')) m[++j]=' ';
        else
            m[++j]=n[i]; // single literals
    }

    m[++j]='|';
    m[++j]='\0';
    return m;
}

— Khaled.K
स्रोत

1

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 61

सरणी समझ का उपयोग करना जो अब मानक एक्मास्क्रिप्ट नहीं है

f=>'|'+[for(c of f)+c?' |'.repeat(c):c<'A'?`
|`:c+'|'].join``

परीक्षा

F=f=>'|'+[for(c of f)+c?' |'.repeat(c):c<'A'?`\n|`:c+'|'].join``

console.log=x=>O.textContent+=x+'\n'

;['8/8/8/8/8/8/8/8','rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR',
'r1bk3r/p2pBpNp/n4n2/1p1NP2P/6P1/3P4/P1P1K3/q5b1']
.forEach(t=>console.log(F(t)+'\n'))

<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

1

लुआ, 106 बाइट्स

print("|"..(...):gsub(".",function(c)return c:find("%d")and(" |"):rep(c)or c=="/"and"\n|"or c.."|"end),'')

Ungolfed

print("|"..                   -- prepend | to the following string
  (...):gsub(".",function(c)  -- iterate over each character in the argument
    return                    -- replaces in the argument
           c:find("%d")       -- if c is a number
             and(" |"):rep(c) --   replace by " |"*c
           or c=="/"          -- elseif c is a slash
             and"\n|"         -- replace by "\n|"
           or c.."|"          -- else (case letter)replace by c
  end)                        -- return the modified string
,'')                          -- add an empty parameter to print
                              -- it suppresses the second output of gsub

— Katenkyo
स्रोत

print((...):gsub(".",function(c)return(c:find("%d")and("| "):rep(c)or c=="/"and"|\n"or"|"..c)end).."|")

— लीक नन

— लीकी नून

print((...):gsub("%d",function(c)return("| "):rep(c)end):gsub("([^%d |])","|%1"):gsub("/","\n").."|")है 101 बाइट्स

— लीकी नून

1

आर (प्रतियोगिता से बाहर)

क्षमा करें यदि यह पोस्ट करना उचित नहीं है, लेकिन मुझे लगा कि यह अच्छा था कि मैं सिर्फ एक फ़ंक्शन के आसपास पड़ा था जो वास्तव में संपादन के बिना इस प्रश्न के लिए काम करता है! यह यूसीआई के बजाय यूनिकोड आउटपुट प्रिंट करता है, हालांकि। मुझे यह याद नहीं है कि मैंने इसे क्यों लिखा है, लेकिन यह एक चुनौती का जवाब नहीं था।

function(x){
# x = FEN position, a string
# can be split with / or ,
# example: forsythe("rnbqkbnr/pp1ppppp/8/2p5/4P3/5N2/PPPP1PPP/RNBQKB1R")

allowed <- c(paste(1:64), 
c("k", "q", "r", "b", "n", "p", "K", "Q", "R", "B", "N", "P"))
chars <- strsplit(x, "")[[1]]
chars <- chars[-which(!(chars %in% allowed))]
out <- c()
for (i in 1:length(chars)){
  if (chars[i] %in% paste(1:64)){
    out <- c(out, rep(" ", as.numeric(chars[i])))
  }
  else{
    out <- c(out, chars[i])
  }
}
if (length(out) < 64) out <- c(out, rep(" ", 64-length(out)))

pieces <- strsplit("KQRBNPkqrbnp", "")[[1]]
unicode <- c("\u2654", "\u2655", "\u2656", 
"\u2657", "\u2658", "\u2659", "\u265A", "\u265B", 
"\u265C", "\u265D", "\u265E", "\u265F")

for (i in 1:64){
  if (out[i] %in% pieces){
    out[i] <- unicode[which(pieces==out[i])]
  }
  else{
  }
}
out <- matrix(out, nc=8, byrow=T)
#print(out)

plot(0, xlim=c(0, 8), ylim=c(0, 8), type="n", xaxt="n", yaxt="n",
xlab="", ylab="")
for (i in 0:7){ for (j in 0:7){ rect(i, j, i+1, j+1,
col=ifelse(((i+j) %% 2) == 0, grey(0.95), "white"), border=F) }}

for (i in 0:7){ for (j in 0:7){
  text(i+0.5, j+0.5, out[8-j, i+1], cex=2)  
}}

axis(1, labels=letters[1:8], at=1:8 - 0.5, tick=F)
axis(2, labels=paste(1:8), at=1:8-0.5, las=2, tick=F)

}

— Flounderer
स्रोत

हमारे सहायता केंद्र राज्य में उल्लिखित नियम हैं कि चुनौतियों के सभी समाधानों में उपयोग में जीतने के मानदंडों के लिए एक गंभीर दावेदार होना चाहिए। कोड गोल्फ के लिए, इसका मतलब है कि सभी उत्तरों को गोल्फ होना चाहिए।

— डेनिस

तकनीकी रूप से, यह गोल्फ है। बस बहुत अच्छी तरह से नहीं।

— फ्लॉडरर

0

हास्केल, 110 बाइट्स

p '/'="\n"
p c|'1'<=c&&c<='8'=replicate(read[c])' '
p c=[c]
main=getLine>>=putStrLn.('|':).(>>=(:"|")).(>>=p)

Ungolfed:

p c | c=='/'           = "\n"
    | '1'<=c && c<='8' = replicate (read [c]) ' '
    | otherwise        = [c]
addPipes string = "|" ++ concatMap (\c -> [c] ++ "|") string
main = getLine >>= putStrLn . addPipes . concatMap p

— viercc
स्रोत

0

जावा 7, 190 184 बाइट्स

String Z(int c){String m="";if(c==47)m+="|\n";else if(c>57)m+="|"+c;else while(c-->48)m+="| ";return m;}String C(String n){String m="";for(char x:n.toCharArray())m+=Z(x);return m+"|";}

विस्तृत ऑनलाइन प्रयास करें

public static String Z(char c)
{
    String m="";
    if(c=='/')m+="|\n";
    else if(c>'9')m+="|"+c;
    else while(c-->'0')m+="| ";
    return m;
}

public static String C(String n)
{
    String m="";
    for(char x:n.toCharArray())m+=Z(x);
    return m+"|";
}

— Khaled.K
स्रोत

आप तुलना में चार लीटर के बजाय पूर्णांक का उपयोग करके बाइट्स के एक जोड़े को बचा सकते हैं

— ब्लू

@ ब्लैक नोट लिए गए

— खालिद.के

0

पाइके, 25 20 बाइट्स

FD~u{RIbd*(s\/n:k\|:

स्पष्टीकरण:

F         (          -    for char in input:
 D~u{RI              -     if char in '0123456789': 
       bd*           -      char = " "*int(char)
           s         -   sum(^)
            \/n:     -  ^.replace("/","\n")
                k\|: - ^.replace("", "|")

यहाँ कोशिश करो!

— नीला
स्रोत

0

पायथन, 84 बाइट्स

lambda a:"".join(c*c.isalpha()or"\n"*(c=="/")or" "*int(c)for c in a).replace("","|")

स्पष्टीकरण:

        c*c.isalpha()                                                       - if c is alphabetical, use c
                       "\n"*(c=="/")                                        - if it's "|", replace it with a newline
                                      " "*int(c)                            - else its an int.
"".join(                                                  ).replace("","|") - interweave "|" between the chars

— नीला
स्रोत

0

> <>, 64 बाइट्स

<v?(0:i
r\
"<o-*=@"%/":   v?*(@)@":/"::;?(0:o"|
 ^~?="0":-1o" "<

4 व्यर्थ बाइट्स संरेखण मुद्दों के कारण, निश्चित नहीं कि उन्हें कैसे बाहर निकालना है। ¯ \ _ (ツ) _ / ¯

— सोक
स्रोत

एक Forsyth- एडवर्ड्स संकेतन स्ट्रिंग को ASCII कला में बदलें

इनपुट

उत्पादन

पर्ल, 28 बाइट्स

रेटिना, 13 बाइट्स

व्याख्या

रूबी - 75 82 78 76 75 62 59 58 57 56 बाइट्स

पायथ - 24 22 21 बाइट्स

पायथ, 23 बाइट्स

जावास्क्रिप्ट ईएस 7, 80 70 बाइट्स

व्याख्या

जूलिया, 62 बाइट्स

05AB1E , 21 बाइट्स

जावास्क्रिप्ट (ईएस 6), 69 67 62 बाइट्स

रेटिना , 50 45 बाइट्स

जोल्फ, 28 बाइट्स

पायथन 3.5, 112 बाइट्स:

सी, 252 बाइट्स

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 61

लुआ, 106 बाइट्स

Ungolfed

आर (प्रतियोगिता से बाहर)

हास्केल, 110 बाइट्स

Ungolfed:

जावा 7, 190 184 बाइट्स

पाइके, 25 20 बाइट्स

पायथन, 84 बाइट्स

> <>, 64 बाइट्स