Tekel Kurulu

Bu kod-golf mücadelesi için tahta oyunu Tekel inşa edeceğiz.

Kurallar:

• Giriş yapmayın.
• Kartı oluşturan her ASCII karakterinin, Monopoly kartının ABD versiyonunun her bir alanının ilk harfi olduğu 11x11'lük bir anakart çıkartın.
• Karakterler boşluklarla ayrılmalıdır.
• Go sağ alttan başlamalıdır.

Üretilecek tam dize

F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 

Sağ alttan sola doğru karelerin aşağıdaki gibi olduğuna dikkat edin:

G --> Go
M --> Mediterranean Avenue
C --> Community Chest
B --> Baltic Avenue
I --> Income Tax
...
J --> Jail

Vay Düzenle ! beyler, bundan hoşlandığınızdan emin misiniz? :)

Retina , 74 bayt

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG
S_`(._.)
_
9$*
\B

1

Üçüncü ve sonuncu satırlar tek bir boşluk içermelidir.

Çevrimiçi deneyin!

açıklama

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Bu (boş) girişini ikinci satırdaki dizeyle değiştirir.

S_`(._.)

Bu, dizgiyi regex'in eşleşmeleri etrafına bölen (._.)(yani, _ortadaki herhangi üç karakterden oluşan ) bölünmüş aşamadır . Tüm regex'i bir gruba koymamızın nedeni, bölünmüş aşamaların da yakalama gruplarının sonuçlarını döndürmesidir. Örneğin abcdetrafa bölmek bcverir [a, d], ama etrafa bölmek b(c)verir [a, c, d]. Bu şekilde tüm ._.parçaları ayrı hatlara, aynı zamanda başlangıçtaki ve sondaki 11 karakterlik kısımlara kavuşturuyoruz. _Bireysel ._.eşleşmeler arasında boş sonuçları atlamak için bu seçeneği kullanıyoruz . Sonuç şöyle olurdu:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Sonra alt çizgi işlenir:

_
9$*

Bu, her alt çizgiyi dokuz 1s ile değiştirir . 1Hemen boşluk yerine burada kullanmamızın nedeni , dolgu boşluklarını daha sonra yerleştirmeyi kolaylaştırmasıdır.

\B

İkinci satırda boşluk olduğunu unutmayın. Bu uçlar her pozisyonda bir boşluk değil bir kelime sınırı, yani her yerde hatların başında ve sonunda hariç.

1

Ve son olarak, tüm bunları 1boşluklarla değiştiririz .

Jöle , 44 bayt

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G

Çevrimiçi deneyin!

Fikir

Her ikinci sütunu kaldırır ve satırları sütunlarla birlikte devredersek, aşağıdaki panoyu alırız.

FNTCSPVSESJ
K         C
C         V
I         C
I         O
B         R
A         I
V         B
W         C
M         M
GPNCPSCPLBG

Artık her bir sütunu bir birim sağa döndürerek kalan tüm alanları sağa taşıyabiliriz.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Sonra kalan boşlukları kaldırır ve satır beslemelerini D harfi ile değiştiririz .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Şimdi, her bir harfi alfabedeki 1-temelli indeksi ile değiştiriyoruz.

10  6 14 20  3 19 16 22 19  5 19  4  3 11  4 22  3  4  3  9  4 15  9  4 18
 2  4  9  1  4  2 22  4  3 23  4 13 13  4  7  7 16 14  3 16 19  3 16 12  2

Daha sonra, bu sayı dizisini bijective 23 tabanından tam sayıya dönüştürürüz.

54580410997367796180315467139871590480817875551696951051609467717521

Şimdi, bu tamsayıyı 250 üssüne dönüştürüyoruz .

  2 232  57  78 163  84 132  77 228 144  27 100  77 176 195
 42   9  55  83 167 155   1 210 125 211   4 232 119  20

Son olarak, bu rakamları Jelly'in kod sayfasına endekslemek için kullanıyoruz .

£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ

Bu, programa dahil edeceğimiz kodlanmış veridir ( 29 bayt ). İstenilen çıktıyı üretmek için yukarıdaki adımları tersine çevirmeliyiz.

kod

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’ḃ23ṣ4ịØAz⁶ṙ1G  Main link. No arguments.

“£ċ9NɲT⁴MỵƇñdMỊḞ*µ7Sʂɓ¢Ż}ạ¥ċwÞ’               Convert the string from bijective
                                              base 250 (using the indices in
                                              Jelly's code page) to integer.
                               ḃ23            Convert that integer to bijective
                                              base 23.
                                  ṣ4          Split the resulting array at
                                              occurrences of 4.
                                    ịØA       Replace the remaining digits in the
                                              resulting 2D array with the
                                              corresponding uppercase letters.
                                       z⁶     Zip/transpose rows and columns,
                                              padding shorter rows with spaces.
                                         ṙ1   Rotate the rows one unit down.
                                           G  Grid; join rows by spaces, columns
                                              by linefeeds.

05AB1E , 48 47 bayt

Bir bayt kaydettiğiniz için Emigna için teşekkürler !

•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»

Açıklama:

İlk önce biraz sıkıştırma. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•aşağıdaki sayının sıkıştırılmış bir versiyonudur:

120860198958186421497710412212513392855208073968557051584380118734764403017

Bundan sonra, bu, aşağıdaki dizgeye sonuçlanan 33 tabanına dönüştürülür :

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Sıfırlar , aşağıdaki kod kullanılarak 9 boşluk ile değiştirilir ¾9ð×:. Ondan sonra Sdizgiyi karakterlere ayırıp 11 elementin (ile yapılır 11ô) parçalarına ayırıyoruz . Aşağıdaki 2 boyutlu diziyi elde ettik:

[['F', 'K', 'C', 'I', 'I', 'B', 'A', 'V', 'W', 'M', 'G'], 
 ['N', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['T', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'N'], 
 ['C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'S'], 
 ['V', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'C'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P'], 
 ['E', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'L'], 
 ['S', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'B'], 
 ['J', 'C', 'V', 'C', 'O', 'R', 'I', 'B', 'C', 'M', 'G']]

Biz gridify bununla dizi »ve örtük çıktı onu.

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Python 2, 89 bayt

l='%s '*11+'\n'
print(l+'%s%20s\n'*9+l)%tuple("FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG")

Şablonu oluşturur

? ? ? ? ? ? ? ? ? ? ? 
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
?                   ?
? ? ? ? ? ? ? ? ? ? ? 

dize biçimlendirme yoluyla harflerin yerine geçmek için. Şablon iki tür satır kullanır:

• l11 satırdan oluşan dış satır harf artı boşluk, ardından yeni satır. Ayrıca ilk ve son satır için kullanılır. Sonunda bir boşluk var.
• Bir karakterin iç çizgisi, ardından 19 karakterlik dolgu boşluklarından önce gelen bir karakter, ardından yeni bir satır. Merkez çizgiler için 9 kez kopyalandı.

Python 3.5, paket açma işleminde bir bayttan tasarruf sağlayabilir (*'...',).

PowerShell v2 +, 131 123 114 110 99 bayt

'F K C I I B A V W M G
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
J C V C O R I B C M G'-replace0,(" "*19)

Bu biraz ile, boru hattı üzerine yerleştirilen yenisatırlar ile sadece bir hazır dizedir -replaceçevirmek sonunda 0içine 19boşluk. İlk ve son satırlar sadece sözlü. Sadece 10 boşluk ve aksi halde az tekrar yapıldığı için, onları golf oynamak için yeterli alan yoktu. Bu dize, boru hattında bırakılır ve örtülü yoluyla çıktı Write-Outputprogram tamamlandığında gerçekleşir.

PS C:\Tools\Scripts\golfing> .\take-a-ride-on-reading.ps1
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G

Javascript ES6 REPL , 105 102 101 bayt

Burada olan pek ilginç değil. İstenilen sonuçları görmek için konsola yapıştırın

@Arnauld sayesinde 3 bayt
kaydedildi @Neil sayesinde 1 bayt kaydedildi

`FKCIIBAVWMG
N P
T N
C C
S P
P S
V C
S P
E L
S B
JCVCORIBCMG`.replace(/.( ?)/g,`$& `+`$1`.repeat(17))

a.innerHTML = 

`FKCIIBAVWMG
N P
T N
C C
S P
P S
V C
S P
E L
S B
JCVCORIBCMG`.replace(/.( ?)/g,`$& `+`$1`.repeat(17))

<pre id=a>

/// , 100 98 bayt

/s/    //p/ssss   //q/pC
SpP
//!/ C /F K!I I B A V W M G 
NpP
TpN
CqPpS
VqEpL
SpB
J!V!O R I B!M G 

Çevrimiçi deneyin!

Bazı gizemli nedenlerden dolayı, Gs sonra izleyen boşluk var gibi görünüyor . Onlar olmasaydı, kodum 96 bayt olurdu.

Her biri 1 baytı azaltmak için 42545 (ETHproductions) ve 56258 (daHugLenny) sayesinde !

Turtlèd , 72 bayt

"K C I I B A V W M G">"GPNCPSCPLBG">"G M C B I R O C V C J">"JSESVPSCTNF

Çevrimiçi deneyin

>kaplumbağayı döndürür, "foo"telleri ızgaraya yazar. son uygun "oldu

V , 75, 62 , 59 bayt

iFKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG-ò9á lli
òÍ./& 

Çevrimiçi deneyin!

Bu kod, ASCII olmayan karakterler içerdiğinden, burada bir hexdump:

0000000: 6946 4b43 4949 4241 5657 4d47 0a4e 5054  iFKCIIBAVWMG.NPT
0000010: 4e43 4353 5050 5356 4353 5045 4c53 420a  NCCSPPSVCSPELSB.
0000020: 4a43 5643 4f52 4942 434d 471b 2df2 39e1  JCVCORIBCMG.-.9.
0000030: 206c 6c69 0af2 cd2e 2f26 20               lli..../& 

Açıklama. İlk önce aşağıdaki metni giriyoruz:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Sonra <esc>normal moda dönüyoruz. Bu noktada, imleç sondaki üçüncü satırdadır G. Elverişli olarak, imlecin hemen üzerindeki satırın ilk sütununa koymak için bir komut var. Bu komut -. Sonra, ikinci satıra gelince (onda N), aşağıdaki döngüyü çalıştırırız:

ò9á lli
ò

Açıklama:

ò           " Recursively:
 9á         "   Append 9 spaces
    ll      "   Move to the right twice. This will fail on the last time because there isn't a space to move into
      i     "   Enter a newline
ò           " End

Şimdi, tampon bu gibi görünüyor:

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG

Şimdi her karakteri bu karakterle ve boşlukla değiştirmek için sıkıştırılmış bir regex kullanıyoruz. Bu Í./&kısmı. Bu, aşağıdaki vim regex'e çevirir:

:%s/./& /g

Bunun anlamı:

:%          " On any line
  s/        " Substitute
    ./      " Any character with
      & /   " That same character and a space
         g  " Allow for multiple substitutions on the same line

R, 149 146 bayt

Çok etkileyici değil, aynı zamanda nasıl golf oynayacağından da emin değil. Her pastenasılsa araştırmak ilk tahminim. 241 bayt ham metinle karşılaştırın.

x=strsplit("NTCSPVSESPNCPSCPLB","")[[1]];cat("F K C I I B A V W M G\n");for(i in 1:9)cat(x[i],rep("",18),x[i+9],"\n");cat("J C V C O R I B C M G")

R keman

Python 2, 108 bayt

Diğer python cevabından biraz farklı, hiçbir değiştirici kullanılmıyor, sadece string birleştiriliyor.

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))

Perl, 90 bayt

Oldukça sıkıcı bir yaklaşım, azaltmak için daha iyi bir yol düşünemiyorum ... -EEk bir ücret ödemeden gerektirir . Her satırın sonunda ek bir alan çıkarır. @Dada sayesinde -2 bayt !

say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr

kullanım

perl -E 'say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'

Jolf, 72 bayt

Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"wΖhζ♣

Tümünü ♣ile değiştirin \x05veya burada deneyin!

Ζ0ρ,ahtht"111"'.d?=H♣Q♣+."..."wΖhζ♣
Ζ0                                   ζ = 0
   ,ahtht"111"                       a box of width&height 11, with borders "1"
  ρ           '.d                    replace each char in that string with...
                 ?=H♣                 is it a space?
                     Q♣                if so, return two spaces.
                                      otherwise
                        ."..."         get the Nth member of this string
                              wΖhζ      where N = (++ζ) - 1
                       +          ♣      and add a space to the end

Bu istenen dize verir.

Java 7, 177 165 142 131 bayt

String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM".replace("_","         ").replace(""," ");}

-BassdropCumberwubwubwub sayesinde -15 bayt . @11knot @
-11 bayt .

Ungolfed ve test kodu:

Burada dene.

class M{
  static String c(){
    return "FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCGM"
      .replace("_","         ").replace(""," ");
  }

  public static void main(String[] a){
    System.out.print(c());
  }
}

Çıktı:

F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G

Befunge, 120 bayt

<v"FKCIIBAVWMG NPTNCCSPPSVCSPELSB $JCVCORIBCMG "
:<,*48 ,_v#-*48<
>1-:#v_\,>$52*, :48*-!#v_,54*
^,*84<         ^p19*88$<

İlk satırın tersi basılacak dizesi var (öyle gözükmüyor, ancak kod bu satır üzerinde geriye doğru gidiyor). İkinci satır üst ve alt satırları yazdırır. Üçüncü satır ve dördüncü satırın sol tarafı orta satırları yazdırır ve sağ alt kısımdaki küçük yığın ilginç bir şey yapar: imleci son satırın çıktısını almak için tekrar ikinci satıra götürür, ancak bitirdikten sonra sonlandırılıyor.

İlk satırda görebileceğiniz gibi, ilk, orta ve son satırları ayırt etmek için dizeler boşluklarla ayrılır. Boşluklar başka bir şey olabilir ve eğer ASCII 0-9 karakterlerini kullanırsam, 4 baytı kolayca kaydedebilirdim. Gördüğünüz $, orada olması gereken ve boşluktan başka bir şeyle değiştirilebilecek bir çöp karakterdir.

J, 77 73 bayt

' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5

Toplamın yarısından fazlasına 43 baytın sadece dizge için kullanıldığını unutmayın ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'.

açıklama

İlk önce bir liste yap

   |i:5
5 4 3 2 1 0 1 2 3 4 5
   5-|i:5
0 1 2 3 4 5 4 3 2 1 0

O zaman onun zaman çizelgesini yap

   */~5-|i:5
0 0  0  0  0  0  0  0  0 0 0
0 1  2  3  4  5  4  3  2 1 0
0 2  4  6  8 10  8  6  4 2 0
0 3  6  9 12 15 12  9  6 3 0
0 4  8 12 16 20 16 12  8 4 0
0 5 10 15 20 25 20 15 10 5 0
0 4  8 12 16 20 16 12  8 4 0
0 3  6  9 12 15 12  9  6 3 0
0 2  4  6  8 10  8  6  4 2 0
0 1  2  3  4  5  4  3  2 1 0
0 0  0  0  0  0  0  0  0 0 0

Sonra eşitliği sıfırla test edin

   0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 1

Düzleştirin, birikimli toplamları bulun ve elementwise ile çarpın

   ,0=*/~5-|i:5
1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1
   +/\,0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 12 12 12 12 12 12 12 12 12 13 14 14 14 14 14 14 14 14 14 14 15 16 16 16 16 16 16 16 16 16 16 17 18 18 18 18 18 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 23 24 24 24 24 24 24 24 24 24 24 25 26 26 26 26 26 26 26 26 26 26 27 28 28 28 28 28 28 28 28 28 28 29 30 31 32 33 34 35 36 37 38 39 40
   (*+/\),0=*/~5-|i:5
1 2 3 4 5 6 7 8 9 10 11 12 0 0 0 0 0 0 0 0 0 13 14 0 0 0 0 0 0 0 0 0 15 16 0 0 0 0 0 0 0 0 0 17 18 0 0 0 0 0 0 0 0 0 19 20 0 0 0 0 0 0 0 0 0 21 22 0 0 0 0 0 0 0 0 0 23 24 0 0 0 0 0 0 0 0 0 25 26 0 0 0 0 0 0 0 0 0 27 28 0 0 0 0 0 0 0 0 0 29 30 31 32 33 34 35 36 37 38 39 40

Ardından sıfırlarla bir araya getirin, uzunluğu 22 alt listeye ayırın, her alt listenin başını bırakın ve değerleri dizgede indeks olarak kullanın ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'

   ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'{~_22}.\,0,.(*+/\),0=*/~5-|i:5
F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G

Aslında , 74 bayt

"%s"9⌐α' j;"%s%20s"9α'
j(k'
j"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%

Çevrimiçi deneyin!

Bu program, xnor'ın Python 2 cevabı ile aynı temel prensipte çalışır .

Açıklama ( \nnetlik için değiştirilen yeni satırlar ):

"%s"9⌐α' j                                       ' '.join(["%s"]*11)
;                                                duplicate
"%s%20s"9α'\nj                                   '\n'.join(["%s%20s"]*9)
(                                                move bottom of stack to top
k'\nj                                            '\n'.join(stack)
"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"#@%                    %tuple(longstring)

C # 6, 192 190 Bayt

using System.Linq;
string f()=>string.Join("\n","FKCIIBAVWMG~N!P~T!N~C!C~S!P~P!S~V!C~S!P~E!L~S!B~JCVCORIBCMG".Replace("!","         ").Split('~').Select(s=>string.Join(" ",s.Select(c=>c))));

İz bırakmadan; newline izlemeden.

Basit bir çözüm. Değişmez dize ile başlayın. Replace !9 boşlukla. Sonra Split11 dize ~ve chars (iç Select). Her karaktere bir boşluk ekleyin, sonra Join11 karaktere geri dönün. Sonunda Joinnewline karakteri ile başka .

Ruby, 92

Tam program kullanarak stdout'a yazdırır $> <<

40.times{|i|$><<"FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG"[i]+(i%29>9?[$/,' '*19][i%2]:' ')}

Çizilecek toplam 40 tane mektup var. 10 ila 28 arasındaki harfler, yeni bir satır veya tarafından takip edilmek üzere değişir ' '*19. Önceki ve sonraki harfler tek boşluklarla ayrılır.

Perl, 115 112 bayt

print FKCIIBAVWMG=~s/(.)/\1 /gr.NPTNCCSPPSVCSPELSB=~s/(.)(.)/"\n$1".$"x19 .$2/gre."\nJCVCORIBCMG"=~s/(.)/\1 /gr;

Aşağıdaki çıktıyı üretir:

F K C I I B A V W M G 
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G 

İlk ve son çıktı satırlarının sonda alanı vardır. Kod, regex değiştirmelerinden ve nesneler tanımlanmadığı takdirde, dizeler olarak yorumlanması gerçeğinden yararlanır (örneğin, FKCIIBAVWMG, "FKCIIBAVWMG" olarak kabul edilir.) Başka hiçbir yerde kandıramazdım.

Düzenleme 1: Kaydedilen 3 bayt değiştirerek " "ile $", dış parantez kaldırılması ve baskı sonra boşluk ekleme ve parantez içine kaldırarak $"x19ve sonrasında bir boşluk ekleyerek (böylece .ondalık olarak yorumlanır olmaz)

Kömür , 66 bayt

Ｂ²¹¦¹¹F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN

Çevrimiçi deneyin!

Box(21, 11, 'F K C I I B A V W M GPNCPSCPLBG M C B I R O C V C JSESVPSCTN').

Rekabet etmeyen, 36 bayt

Python 2, 116 Bayt

Oldukça basit, herhangi bir sebepten dolayı dize değiştirmek o kadar ayrıntılı olsa da, bulabildiğim en iyi şeydi. Muhtemelen kullanmak redaha kısa olabilir.

print' '.join('FKCIIBAVWMG!N@P!T@N!C@C!S@P!P@S!V@C!S@P!E@L!S@B!JCVCORIBCMG').replace(' ! ','\n').replace('@',' '*17)

Toplu iş, 171 bayt

@echo F K C I I B A V W M G
@set s=NPTNCCSPPSVCSPELSB
:l
@echo %s:~0,1%                   %s:~1,1%
@set s=%s:~2%
@if not "%s%"=="" goto l
@echo J C V C O R I B C M G

GameMaker Dili, 148 bayt

Bunun oldukça basit olduğunu biliyorum, ama bunun GML’de atılabileceğini sanmıyorum ...

a="                   "return"F K C I I B A V W M G #N"+a+"P#T"+a+"N#C"+a+"C#S"+a+"P#P"+a+"S#V"+a+"C#S"+a+"P#E"+a+"L#S"+a+"B#J C V C O R I B C M G "

Pip , 64 bayt

63 bayt kod, -Sbayrak için +1 .

.*"NTCSPVSES".sX19.^"PNCPSCPLB"PE^"FKCIIBAVWMG"AE^"JCVCORIBCMG"

Çevrimiçi deneyin!

açıklama

Kullanılan operatörler:

• . (ikili) bitiştir (listelerde öğe şeklinde çalışır).
• X(ikili) dize çarpar. ( sönceden başlatılmış bir değişkendir " ".)
• ^ (unary) bir dizgiyi bir karakter listesine böler.
• .*dizeyi karakterlere ayırmanın başka bir yoludur. Bu tekli oluşmaktadır .ile eşleştirilmiş dizeleri üzerinde no-op olan *her biri (iterable) öğenin işlenen bir tek işlem işleci eşleyen meta operatörü. Kullanmak .*"..."bir bayttan fazla tasarruf etmemize olanak tanır (^"...")- parantez gerekli olacaktır ., çünkü önceliğe göre daha yüksektir ^.
• PEbir listeye bir eleman hazırlar. AEbir listeye bir öğe ekler.

Bu arka planla, işte adım adım kod:

.*"NTCSPVSES"

['N 'T 'C 'S 'P 'V 'S 'E 'S]

.sX19

["N                   "
 "T                   "
 "C                   "
 "S                   "
 "P                   "
 "V                   "
 "S                   "
 "E                   "
 "S                   "]

.^"PNCPSCPLB"

["N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]

PE^"FKCIIBAVWMG"

[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"]

AE^"JCVCORIBCMG"

[['F 'K 'C 'I 'I 'B 'A 'V 'W 'M 'G]
 "N                   P"
 "T                   N"
 "C                   C"
 "S                   P"
 "P                   S"
 "V                   C"
 "S                   P"
 "E                   L"
 "S                   B"
 ['J 'C 'V 'C 'O 'R 'I 'B 'C 'M 'G]]

Bu sonuç otomatik olarak yazdırıldığında, -Sbayrak alanlardaki alt listelere ve yeni satırlardaki ana listeye katılarak istenen sonucu elde eder.

C, 171 156 Bayt

i,j;char*b="FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG ";f(){for(i=1;*b;j=i%21==0?putchar(*b++),puts(""),i++,*b++:i<21||i>210?i&1?*b++:32:32,putchar(j),i++);}

Sonunda yeni bir karakter çıkarır ... Muhtemelen biraz daha golf oynayabilir.

Perl 5, 92 86 bayt

• Dada sayesinde 6 bayt kurtardı

$a="%s "x11;printf"$a
"."%s%20s
"x9 .$a,FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG=~/./g

Kullanımlar sprintf, dolgu ve string operatörü tekrar eder x.

Haskell, 128 125 114 bayt

mapM(putStrLn.((:" ")=<<))$"FKCIIBAVWMG":zipWith(\a b->a:"         "++[b])"NTCSPVSES""PNCPSCPLB"++["JCVCORIBCMG"]

Burada dene

• ((:" ")=<<)is concatMap (\a -> [a,' '])- girişindeki her harfin arkasına boşluk ekleyerek pedleri

Powershell, 95 bayt

AdmBorkBork en @ esinlenerek cevap .

'FKCIIBAVWMG
N0P
T0N
C0C
S0P
P0S
V0C
S0P
E0L
S0B
JCVCORIBCMG'-replace0,(' '*9)-replace'.','$0 '

açıklama

İlk değiştirme operatörü dikdörtgeni yapar 11x11.

FKCIIBAVWMG
N         P
T         N
C         C
S         P
P         S
V         C
S         P
E         L
S         B
JCVCORIBCMG

İkinci değiştirme operatörü, her karakterden sonra bir boşluk ekler. Sonuçta sondaki boşluklar var.

F K C I I B A V W M G
N                   P
T                   N
C                   C
S                   P
P                   S
V                   C
S                   P
E                   L
S                   B
J C V C O R I B C M G