Monopolbehörde

Für diese Code-Golf-Herausforderung bauen wir das Brettspiel Monopoly auf.

Regeln:

• Nehmen Sie keine Eingabe.
• Geben Sie eine 11x11-Karte aus, bei der jedes ASCII-Zeichen, das die Karte bildet, der erste Buchstabe jedes Leerzeichens der US-Version der Monopoly-Karte ist.
• Die Zeichen müssen durch Leerzeichen getrennt werden.
• Go sollte unten rechts beginnen.

Die genaue zu produzierende Zeichenfolge ist

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 

Beachten Sie, dass die Quadrate von rechts unten nach links unten wie folgt sind:

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

Bearbeiten Wow! euch hat das wirklich gefallen! :)

Netzhaut , 74 Bytes

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

1

Die vorletzte und letzte Zeile sollte ein Leerzeichen enthalten.

Probieren Sie es online!

Erläuterung

FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Dadurch wird die (leere) Eingabe durch die Zeichenfolge in der zweiten Zeile ersetzt.

S_`(._.)

Dies ist eine geteilte Phase, bei der die Zeichenfolge um Übereinstimmungen der Regex (._.)( dh drei beliebige Zeichen mit einem _in der Mitte) aufgeteilt wird. Der Grund, warum wir den gesamten regulären Ausdruck in eine Gruppe einteilen, ist, dass geteilte Phasen auch die Ergebnisse der Erfassung von Gruppen zurückgeben. ZB Splitting abcdum bcgibt [a, d], aber Splitting es um b(c)gibt [a, c, d]. Auf diese Weise erhalten wir alle ._.Teile in separaten Zeilen, aber auch die 11-stelligen Teile am Anfang und Ende. Wir verwenden die _Option, um leere Ergebnisse zwischen den einzelnen ._.Übereinstimmungen wegzulassen . Das Ergebnis wäre:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Als nächstes verarbeiten wir die Unterstriche:

_
9$*

Dadurch wird jeder Unterstrich durch neun 1Sekunden ersetzt. Der Grund, warum wir 1hier s anstelle von Leerzeichen sofort verwenden, ist, dass es einfacher ist, die Leerzeichen als nächstes einzufügen.

\B

Denken Sie daran, dass in der zweiten Zeile ein Leerzeichen steht. Dadurch wird an jeder Stelle ein Leerzeichen eingefügt, das keine Wortgrenze ist, dh überall außer am Anfang und am Ende der Zeilen.

1

Und schließlich ersetzen wir all diese 1s auch durch Leerzeichen.

Jelly , 44 Bytes

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

Probieren Sie es online!

Idee

Wenn wir jede zweite Spalte entfernen und Zeilen mit Spalten transponieren, erhalten wir die folgende Tabelle.

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

Jetzt können wir jede Spalte um eine Einheit nach rechts drehen und alle verbleibenden Leerzeichen nach rechts verschieben.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Dann entfernen wir die übrigen Räume und ersetzen Zeilenvorschübe mit dem Buchstaben D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Jetzt ersetzen wir jeden Buchstaben durch seinen 1-basierten Index im Alphabet.

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

Dann konvertieren wir dieses Ziffernfeld von der bijektiven Basis 23 in eine Ganzzahl.

54580410997367796180315467139871590480817875551696951051609467717521

Nun konvertieren wir diese Ganzzahl in die bijektive Basis 250 .

  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

Schließlich verwenden wir diese Ziffern, um in Jellys Codepage zu indizieren .

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

Dies sind die codierten Daten, die in das Programm aufgenommen werden ( 29 Byte ). Um die gewünschte Ausgabe zu erzeugen, müssen wir nur die obigen Schritte umkehren.

Code

“£ċ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 Bytes

Danke an Emigna für das Speichern eines Bytes!

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

Erläuterung:

Zuerst etwas Komprimierung. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•ist eine komprimierte Version der folgenden Nummer:

120860198958186421497710412212513392855208073968557051584380118734764403017

Danach wird dies in Basis 33 konvertiert , was zu der folgenden Zeichenfolge führt:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Die Nullen werden mit dem folgenden Code durch 9 Leerzeichen ersetzt ¾9ð×:. Danach Steilen wir den String in Zeichen und schneiden sie in Stücke von 11 Elementen (fertig mit 11ô). Wir erhalten das folgende zweidimensionale Array:

[['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']]

Wir gittern dieses Array mit »und geben es implizit aus.

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Python 2, 89 Bytes

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

Erstellt die Vorlage

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

in Buchstaben durch Zeichenfolgenformatierung zu ersetzen. Die Vorlage verwendet zwei Arten von Linien:

• Die äußere Zeile lvon 11 Exemplaren von Buchstaben plus Leerzeichen, dann eine neue Zeile. Es wird auch für die erste und letzte Zeile verwendet. Es hat ein Leerzeichen.
• Die innere Zeile eines Zeichens, gefolgt von einem Zeichen mit 19 Zeichen Abstand, gefolgt von einer neuen Zeile. Es wird 9 Mal für die Mittellinien kopiert.

Mit Python 3.5 kann ein Byte beim Entpacken von Tupeln gespeichert werden (*'...',).

PowerShell v2 +, 131 123 114 110 99 Byte

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

Dies ist nur eine wörtliche Zeichenfolge mit Zeilenumbrüchen in der Pipeline, mit ein wenig -replaceam Ende, um die 0in 19Leerzeichen zu verwandeln . Die erste und letzte Zeile sind nur wörtlich. Mit nur 10 Feldern und wenigen Wiederholungen war nicht genug Platz, um Golf zu spielen. Diese Zeichenfolge verbleibt in der Pipeline, und die implizite Ausgabe Write-Outputerfolgt bei Programmabschluss.

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 Bytes

Hier passiert nicht viel Interessantes. Fügen Sie in die Konsole ein, um die gewünschten Ergebnisse anzuzeigen

3 Byte dank @Arnauld
gespeichert 1 Byte mehr dank @Neil gespeichert

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

/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 

Probieren Sie es online!

Aus irgendeinem mysteriösen Grund scheinen sich nach dem Gs Leerzeichen zu befinden . Ohne sie wäre mein Code 96 Bytes gewesen.

Vielen Dank an 42545 (ETHproductions) und 56258 (daHugLenny) für die Reduzierung von jeweils 1 Byte!

Turtlèd , 72 Bytes

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

Probieren Sie es online aus

>dreht Schildkröte, "foo"schreibt Zeichenketten auf Raster. zuletzt "war elidable

V , 75, 62 , 59 Bytes

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

Probieren Sie es online!

Da dieser Codel Nicht-ASCII-Zeichen enthält, ist hier ein 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..../& 

Erläuterung. Zuerst geben wir den folgenden Text ein:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Dann kehren wir <esc>zum normalen Modus zurück. Zu diesem Zeitpunkt befindet sich der Cursor in der dritten Zeile der letzten Zeile G. Praktischerweise gibt es einen Befehl, um uns in die erste Spalte der Zeile direkt über dem Cursor zu setzen. Dieser Befehl ist -. Sobald wir in der zweiten Zeile (auf der N) landen , führen wir die folgende Schleife aus:

ò9á lli
ò

Erläuterung:

ò           " 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

Der Puffer sieht nun so aus:

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

Jetzt verwenden wir einen komprimierten regulären Ausdruck, um jedes Zeichen durch dieses Zeichen und ein Leerzeichen zu ersetzen. Das ist der Í./&Teil. Dies übersetzt in den folgenden regulären Ausdruck:

:%s/./& /g

Was bedeutet:

:%          " 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 Bytes

Nicht so beeindruckend, aber auch nicht sicher, wie das golfen würde. pasteIrgendwie auszunutzen ist meine erste Vermutung. Vergleiche mit Rohtext von 241 Bytes.

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-Geige

Python 2, 108 Bytes

Etwas anders als die andere Python-Antwort, ohne Ersetzungen, nur String-Joins.

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

Perl, 90 Bytes

Ziemlich langweiliger Ansatz, ich kann mir keinen besseren Weg zum Reduzieren vorstellen ... Erfordert -Ekeine zusätzlichen Kosten. Gibt am Ende jeder Zeile ein zusätzliches Leerzeichen aus. -2 Bytes dank @Dada !

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

Verwendungszweck

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

Jolf, 72 Bytes

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

Ersetzen Sie alles ♣durch \x05, oder probieren Sie es hier aus!

Ζ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

Dies ergibt die gewünschte Zeichenfolge.

Java 7, 177 165 142 131 Bytes

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(""," ");}

-15 Bytes dank @BassdropCumberwubwubwub .
-11 Bytes dank @Numberknot .

Ungolfed & Testcode:

Probieren Sie es hier aus.

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());
  }
}

Ausgabe:

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 Bytes

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

In der ersten Zeile wird die Zeichenfolge umgekehrt gedruckt (es sieht so aus, als wäre es nicht so, aber der Code wird in dieser Zeile rückwärts ausgegeben). In der zweiten Zeile werden die oberen und unteren Zeilen gedruckt. Die dritte Zeile und die linke Seite der vierten Zeile geben die mittleren Zeilen aus, und der kleine Block unten rechts macht eine interessante Sache: Er bewegt den Cursor zurück in die zweite Zeile, um die letzte Zeile auszudrucken, aber nachdem er fertig ist quitt.

Wie Sie in der ersten Zeile sehen können, werden die Zeichenfolgen durch Leerzeichen getrennt, um zwischen der ersten, mittleren und letzten Zeile zu unterscheiden. Die Leerzeichen können alles andere sein, und wenn ich die ASCII-Zeichen 0-9 verwendet hätte, hätte ich leicht 4 Bytes speichern können. Das $, das Sie sehen, ist nur ein Müll-Zeichen, das vorhanden sein muss und durch alles andere als ein Leerzeichen ersetzt werden kann.

J 77 73 Bytes

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

Beachten Sie, dass 43 Bytes, also mehr als die Hälfte der Gesamtzahl, nur für die Zeichenfolge verwendet werden ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG' .

Erläuterung

Machen Sie zuerst eine Liste

   |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

Dann mach mal seinen Tisch

   */~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

Dann auf Gleichheit mit Null prüfen

   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

Machen Sie es flach, finden Sie die kumulativen Summen und multiplizieren Sie sie elementweise

   ,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

Verbinden Sie dann mit Nullen, teilen Sie sie in Unterlisten der Länge 22 auf, lassen Sie den Kopf jeder Unterliste fallen und verwenden Sie die Werte als Indizes in der Zeichenfolge ' 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

Eigentlich 74 Bytes

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

Probieren Sie es online!

Dieses Programm basiert auf dem gleichen Grundprinzip wie die Antwort von xnor auf Python 2 .

Erläuterung (Zeilenumbrüche werden \naus Gründen der Übersichtlichkeit durch ersetzt):

"%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 Bytes

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

Ohne Leerzeichen; ohne nachlaufende newline.

Eine einfache Lösung. Beginnen Sie mit der Literalzeichenfolge. Replace !um 9 Felder. Dann Splitin 11 Reihen durch ~und weiter zu chars (inner Select). Fügen Sie jedem Zeichen ein Leerzeichen hinzu und kehren Sie dann Joinzu 11 Zeichenfolgen zurück. Endlich wieder ein JoinNewline-Charakter.

Rubin, 92

Volles Programm, druckt auf Standardausgabe mit $> <<

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

Es sind insgesamt 40 Buchstaben zu zeichnen. Die Buchstaben 10 bis 28 werden abwechselnd von einem Zeilenvorschub oder gefolgt ' '*19. Die früheren und späteren Buchstaben werden durch einzelne Leerzeichen getrennt.

Perl, 115 112 Bytes

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

Erzeugt die folgende Ausgabe:

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 

Die erste und die letzte Ausgabezeile haben ein Leerzeichen am Ende. Der Code nutzt Regex-Ersetzungen und die Tatsache, dass Objekte, die nicht definiert sind, als Zeichenfolgen interpretiert werden (z. B. FKCIIBAVWMG wird als "FKCIIBAVWMG" behandelt. Die Anführungszeichen aus der letzten Zeile konnten aufgrund der vorhergehenden Zeile nicht entfernt werden Ich konnte nirgendwo anders fündig werden.

Edit 1: 3 Bytes gespart durch Ersetzen " "durch $", Entfernen der äußeren Klammern und Einfügen eines Leerzeichens nach dem Drucken, Entfernen der Klammern $"x19und Hinzufügen eines Leerzeichens danach (das wird also .nicht als Dezimalzahl interpretiert)

Kohle , 66 Bytes

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

Probieren Sie es online!

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

Nicht konkurrierend, 36 Bytes

Python 2, 116 Bytes

Ziemlich einfach, aus welchem ​​Grund auch immer, obwohl das Ersetzen von Saiten so ausführlich ist, war es das Beste, was ich mir einfallen lassen konnte. Möglicherweise rekönnte die Verwendung kürzer sein.

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)

Batch, 171 Bytes

@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-Sprache, 148 Byte

Ich weiß, dass es ziemlich einfach ist, aber ich glaube nicht, dass dies in GML zu übertreffen ist ...

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 Bytes

63 Byte Code, +1 für -SFlag.

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

Probieren Sie es online!

Erläuterung

Verwendete Operatoren:

• . (binäre) Verkettung (Funktioniert auf Listen).
• X(binäre) String-Multiplikationen. ( sIst eine Variable, für die vorinitialisiert wurde " ".)
• ^ (unary) teilt einen String in eine Liste von Zeichen.
• .*ist eine andere Möglichkeit, eine Zeichenfolge in Zeichen aufzuteilen. Es besteht aus unary ., einem No-Op für Strings, gepaart mit dem *Meta-Operator, der jedem Element in seinem (iterierbaren) Operanden einen unary-Operator zuordnet. Mit .*"..."können Sie ein Byte vor (^"...")den Klammern speichern, da diese .Vorrang haben ^.
• PEStellt ein Element vor eine Liste. AEHängt ein Element an eine Liste an.

Vor diesem Hintergrund ist hier der Code Schritt für Schritt:

.*"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]]

Wenn dieses Ergebnis automatisch gedruckt wird, verbindet das -SFlag die Unterlisten in Leerzeichen und die Hauptliste in Zeilenumbrüchen und gibt die gewünschte Ausgabe aus.

C, 171 156 Bytes

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++);}

Gibt auch einen abschließenden Newline-Charakter aus ... Könnte wahrscheinlich ein bisschen mehr runtergolfen werden.

Perl 5, 92 86 Bytes

• 6 Bytes gespart dank Dada

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

Verwendet sprintf, Polsterung und den String-Repeat-Operator x.

Haskell, 128 125 114 Bytes

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

Probieren Sie es hier aus

• ((:" ")=<<)is concatMap (\a -> [a,' '])- pads durch Hinzufügen eines Leerzeichens hinter jedem Buchstaben in der Eingabe

Powershell, 95 Bytes

Inspiriert von der Antwort von @ AdmBorkBork .

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

Erläuterung

Der erste Ersetzungsoperator erstellt das Rechteck 11x11.

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

Der zweite Ersetzungsoperator fügt nach jedem Zeichen ein Leerzeichen ein. Das Ergebnis enthält nachgestellte Leerzeichen.

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