Faites un tour sur le Reading, si vous passez Go, collectez 200 $

39

Monopoly Board

Pour ce défi code-golf, nous allons construire le jeu de société Monopoly.

Règles:

  • Ne prenez aucune entrée.
  • Générez une carte 11x11 dans laquelle chaque caractère ASCII constituant la carte est la première lettre de chaque espace de la version américaine de la carte Monopoly.
  • Les caractères doivent être séparés par des espaces.
  • Go devrait commencer en bas à droite.

La chaîne exacte à produire est

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

Notez qu'en bas à droite les carrés sont les suivants:

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

Modifier Wow! vous avez bien aimé celui-ci! :)

code-golf  string  ascii-art  kolmogorov-complexity  board-game 
— Jacksonecac
source
7
Je ne veux pas être insensé, mais ... comment passe-t-on Go tout en se rendant à Boardwalk?
— Sp3000
4
Si vous êtes sur le trottoir :)
— jacksonecac
8
Vous ne pouvez pas obtenir de carte chance si vous êtes sur le trottoir :(
— jacksonecac
27
Je vous ai tous échoué
— jacksonecac
3
Les espaces de fin sont-ils autorisés?
— Adnan

Réponses:

36

Retina , 74 octets


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

1

Les troisième à dernière et dernière lignes doivent contenir un seul espace.

Essayez-le en ligne!

Explication


FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Ceci remplace l'entrée (vide) par la chaîne sur la deuxième ligne.

S_`(._.)

Ceci est une étape scindée, qui scinde la chaîne autour des correspondances de la regex (._.)(c'est-à-dire trois caractères quelconques avec un _au milieu). La raison pour laquelle nous plaçons l'intégralité de la regex dans un groupe est que les étapes fractionnées renvoient également les résultats de la capture de groupes. Fractionnement par exemple abcdautour bcdonne [a, d], mais le fractionnement autour b(c)donne [a, c, d]. De cette façon, nous obtenons toutes les ._.parties sur des lignes séparées, mais également les parties de 11 caractères au début et à la fin. Nous utilisons l’ _option pour omettre les résultats vides entre les ._.matchs individuels . Le résultat serait ceci:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Ensuite, nous traitons les traits de soulignement:

_
9$*

Ceci remplace chaque trait de soulignement par neuf 1s. La raison pour laquelle nous utilisons 1s ici au lieu d'espaces immédiatement est qu'il est plus facile d'insérer les espaces de remplissage après.

\B

Rappelez-vous qu'il y a un espace sur la deuxième ligne. Ceci insère un espace dans chaque position qui n'est pas une limite de mot, c'est-à-dire partout sauf au début et à la fin des lignes.

1

Et finalement, nous remplaçons tous ces 1objets par des espaces.

— Martin Ender
source
1
Bon travail! C'était rapide!
— jacksonecac
39
+1 pour (._.).
— Citron destructible
^ était sur le point de dire que ahha
— jazzboy
25

Gelée , 44 octets

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

Essayez-le en ligne!

Idée

Si nous supprimons une colonne sur deux et transposons des lignes avec des colonnes, nous obtenons le tableau suivant.

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

Maintenant, nous pouvons faire pivoter chaque colonne d'une unité vers la droite, en déplaçant tous les espaces restants vers la droite.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Ensuite, on enlève les espaces restants et remplaçons linefeeds par la lettre D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Maintenant, nous remplaçons chaque lettre par son index basé sur 1 dans l'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

Ensuite, nous convertissons ce tableau de chiffres de la base bijective 23 en entier.

54580410997367796180315467139871590480817875551696951051609467717521

Maintenant, nous convertissons cet entier en base bijective 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

Enfin, nous utilisons ces chiffres pour indexer la page de code de Jelly .

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

Ce sont les données encodées que nous inclurons dans le programme ( 29 octets ). Pour produire la sortie souhaitée, il suffit d’inverser les étapes ci-dessus.

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.
— Dennis
source
5
Merci pour l'explication détaillée. Il est toujours intéressant de voir le processus qui sous-tend les réponses aux questions de code golf. :)
— XtraSimplicity
11
Code Golf - où il est parfaitement normal de voir un numéro en base 250 et base 23.
— corsiKa
Belle technique de compression. Pourquoi la transposition est-elle nécessaire?
— ETHproductions
@ETHproductions Jelly n'a pas d'atome de remplissage. Je peux donc compléter manuellement toutes les lignes avec des espaces de la même longueur ou utiliser le zip dyadic ( z) avec un remplissage.
— Dennis
16

05AB1E , 48 47 octets

Merci à Emigna d' avoir sauvegardé un octet!

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

Explication:

D'abord un peu de compression. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•est une version compressée du numéro suivant:

120860198958186421497710412212513392855208073968557051584380118734764403017

Ensuite, cela est converti en base 33 , ce qui donne la chaîne suivante:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Les zéros sont remplacés par 9 espaces , en utilisant le code suivant ¾9ð×:. Après cela, nous Sfendons la ficelle en caractères et les coupons en morceaux de 11 éléments (réalisés avec 11ô). Nous obtenons le tableau à 2 dimensions suivant:

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

Nous grilleons ce tableau avec »et le sortons implicitement.

Utilise le codage CP-1252 . Essayez-le en ligne!

— Adnan
source
3
Compresser avec 0 au lieu de D enregistre un octet•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»
— Emigna
@ Emigna Ah, c'est malin! Merci :).
— Adnan
12

Python 2, 89 octets

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

Crée le modèle 

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

substituer en lettres via le formatage de chaîne. Le modèle utilise deux types de lignes:

  • La ligne extérieure l de 11 copies de letter-plus-space, puis une nouvelle ligne. Il est également utilisé pour la première et la dernière ligne. Il a un espace de fuite.
  • La ligne intérieure d'un caractère, puis un caractère précédé de 19 caractères d'espaces de remplissage, puis une nouvelle ligne. Il est copié 9 fois pour les lignes centrales.

Python 3.5 peut enregistrer un octet avec la décompression de tuple (*'...',).

— Xnor
source
1
Passer à Python 3.5 devrait sauver un octet.
— Dennis
9

PowerShell v2 +, 131 123 114 110 99 octets

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

Ceci est juste une chaîne littérale avec des nouvelles lignes placées sur le pipeline, avec un peu -replaceà la fin pour transformer le 0en 19espaces. Les première et dernière lignes ne sont que textuelles. Avec seulement 10 espaces et peu de répétition sinon, il n'y avait pas assez de place pour jouer au golf. Cette chaîne est laissée dans le pipeline et la sortie via implicite a lieu Write-Outputà la fin du programme.

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
— AdmBorkBork
source
9

Javascript ES6 REPL , 105 102 101 octets

Pas très intéressant qui se passe ici. Collez dans la console pour voir les résultats souhaités

Enregistré 3 octets grâce à @Arnauld
Sauvegardé 1 octet supplémentaire grâce à @Neil

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

Afficher l'extrait de code

— Bassdrop Cumberwubwubwub
source
Je ne pense pas que REPL est autorisé.
— NoOneIsHere
— Martin Ender
1
J'ai réussi à raser un autre octet. Remplacez le 1s par des espaces et utilisez cette expression rationnelle à la place:.replace(/.( ?)/g,`$& `+`$1`.repeat(17))
— Neil
Une autre façon de supprimer un autre octet consiste à remplacer le 1s par des espaces et à utiliser cette fonction:a=>a-1?a.repeat(18):a+' '
— ETHproductions
@Neil merci, j'adore votre approche!
— Bassdrop Cumberwubwubwub
7

/// , 100 98 octets

/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

Essayez-le en ligne!

Pour une raison mystérieuse, il semble y avoir des espaces de fuite après la G s. Sans eux, mon code aurait été 96 octets.

Merci à 42545 (ETHproductions) et 56258 (daHugLenny) d’ avoir réduit d’un octet chaque!

— Erik l'Outgolfeur
source
@ETHproductions Mauvais lien peut-être? Je ne peux pas sauver un octet comme ça.
— Erik l'Outgolfer
N'est-ce pas 98 octets si vous supprimez l'espace après le Gs sur la première et la dernière ligne?
— Emigna
1
— Erik l'Outgolfer
1
@ Emigna je sais, mais la sortie exacte les contient, je ne les enlèverai donc pas.
— Erik l'Outgolfer
Mon mauvais, essayez ceci .
— ETHproductions
5

V , 75, 62 , 59 octets

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

Essayez-le en ligne!

Comme ce code contient des caractères non-ASCII, voici un 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..../&

Explication. Tout d'abord, nous entrons le texte suivant:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Ensuite, nous <esc>revenons en mode normal. À ce stade, le curseur se trouve sur la troisième ligne de la dernière G. De manière pratique, il existe une commande pour nous placer dans la première colonne de la ligne juste au-dessus du curseur. Cette commande est -. Ensuite, une fois que nous nous retrouvons sur la deuxième ligne (sur laN ), nous exécutons la boucle suivante:

ò9á lli
ò

Explication:

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

Maintenant, le tampon ressemble à ceci:

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

Nous utilisons maintenant une expression rationnelle compressée pour remplacer chaque caractère par ce caractère et un espace. C'est la Í./&partie. Cela se traduit par la regex vim suivante:

:%s/./& /g

Ce qui signifie:

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

R, 149 146 octets

Pas si impressionnant mais aussi pas sûr de savoir comment cela serait joué. L'exploitation pasteest en quelque sorte ma première hypothèse. Comparez au texte brut de 241 octets.

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

— Billywob
source
4

Python 2, 108 octets

Un peu différent de l'autre réponse python, n'utilisant aucun remplacement, uniquement des jointures de chaînes.

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))
— TFeld
source
1
Je savais que zip était la voie à suivre! Avait à peu près la même solution jusqu'à 118 plus tôt et allait jouer au golf ce soir. Il me manquait la carte. Je suppose que tu me bats. +1
— ElPedro
4

Perl, 90 octets

Approche assez ennuyeuse, ne peut pas penser à un meilleur moyen de réduire ... Nécessite -Esans frais supplémentaires. Sort un espace supplémentaire à la fin de chaque ligne. -2 octets grâce à @Dada !

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

Usage

perl -E 'say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'
— Dom Hastings
source
2 octets plus court (mais essentiellement le même code que vous): perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'. (Remplacez \nlittéralement par une nouvelle ligne pour atteindre 90).
— Dada
@ Dada Ahhh, beaucoup mieux! Merci!
— Dom Hastings
"beaucoup de bien" aurait été de trouver une solution de 40 octets, mais merci: D
— Dada
4

Jolf, 72 octets

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

Remplacez tout ♣par \x05, ou essayez-le ici!

Ζ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

Cela donne la chaîne souhaitée.

— Conor O'Brien
source
3

Java 7, 177 165 142 131 octets

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 octets grâce à @BassdropCumberwubwubwub .
-11 octets grâce à @Numberknot .

Non testé et code de test:

Essayez ici.

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

Sortie:

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
— Kevin Cruijssen
source
1
String c(){String s=" ";return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace(""," ").replace("_",s);}pour 150 (notez que stackexchange supprime les espaces excessifs)
— Bassdrop Cumberwubwubwub
@BassdropCumberwubwubwub Umm .. cela ne génère que 3 espaces entre les "murs verticaux", au lieu de 19 .. Voici une idée de votre code.
— Kevin Cruijssen
Par conséquent ma note, il devrait y avoir plus d'espaces dans smais stackexchange les a supprimés. Voici l' idéone , même maintenant à 142 octets
— Bassdrop Cumberwubwubwub
@BassdropCumberwubwubwub Ah ok. Je ne savais pas que tu étais entre le s=" ". Dans ce cas, c'est effectivement plus court. Et .‌​replace(""," ").replace("_",s);peut être à la .replace("_",s).‌​replace(""," ");place pour -8 octets supplémentaires
— Kevin Cruijssen
1
String c(){return"FKCIIBAVWMG\nN_P\nT_N\nC_C\nS_P\nP_S\nV_C\nS_P\nE_L\nS_B\nJCVCORIBCMG".replace("_","&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;").replace(""," ");}( 131 bytes )
— Numberknot
3

Befunge, 120 octets

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

La première ligne contient la chaîne à imprimer en sens inverse (il semble que ce ne soit pas le cas, mais le code revient en arrière sur cette ligne). La deuxième ligne imprime les lignes du haut et du bas. La troisième ligne et le côté gauche de la quatrième ligne impriment les lignes du milieu, et le petit morceau en bas à droite est une chose intéressante: il déplace le curseur vers la deuxième ligne pour imprimer la dernière ligne, mais après l'avoir terminée, quitte.

Comme vous pouvez le voir sur la première ligne, les chaînes sont séparées par des espaces afin de distinguer les première, deuxième et troisième lignes. Les espaces peuvent être n'importe quoi d'autre, et si j'avais utilisé les caractères ASCII 0-9, j'aurais pu facilement sauvegarder 4 octets. Le $ que vous voyez est juste un caractère de poubelle qui doit être présent et pourrait être remplacé par autre chose qu'un espace.

3

J, 77 73 octets

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

Notez que 43 octets, soit plus de la moitié du total, sont utilisés uniquement pour la chaîne. ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG' .

Explication

Tout d'abord, faire une 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

Alors fais sa table des fois

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

Puis testez l'égalité avec zéro

   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

Aplatissez-le, trouvez les sommes cumulées et multipliez-les par élément

   ,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

Joignez-vous ensuite avec des zéros, divisez-le en sous-listes de longueur 22, supprimez la tête de chaque sous-liste et utilisez les valeurs comme indices dans la chaîne. ' 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
— milles
source
Le meilleur que je puisse obtenir avec la compression générique de chaînes est de 90 octets:(' ',@,.~]);._1';FKCIIBAVWMG;N_P;T_N;C_C;S_P;P_S;V_C;S_P;E_L;S_B;JCVCORIBCMG'rplc'_';9#' '
— Conor O'Brien
@ ConorO'Brien Ouais, il est difficile de compresser des chaînes de caractères en J quand d'autres langues ont des dictionnaires et une compression intégrée.
— miles
@ ConorO'Brien J'ai essayé de golfer votre idée un peu plus et je l'ai eu à 76 octets_11,@,.&' '\'FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG'rplc'_';9#' '
— miles
3

En fait , 74 octets

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

Essayez-le en ligne!

Ce programme fonctionne sur le même principe de base que la réponse Python 2 de xnor .

Explication (nouvelles lignes remplacées par \npour plus de clarté):

"%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)
— Mego
source
3

C # 6, 192 190 octets

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

Sans espace de fuite; sans fin de ligne.

Une solution simple. Commencez avec la chaîne littérale. Replace !par 9 espaces. Puis Splitdans 11 chaînes de ~, et plus loin à chars (intérieur Select). Ajoutez un espace à chaque caractère, puis Joinrevenez à 11 chaînes. Enfin un autre Joinpar caractère newline.

— Link Ng
source
3

Ruby, 92

Programme complet, impression sur stdout avec $> <<

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

Il y a 40 lettres au total à tracer. Les lettres 10 à 28 alternent entre suivi d’une nouvelle ligne ou ' '*19. Les lettres antérieures et ultérieures sont séparées par des espaces simples.

— Level River St
source
3

Perl, 115 112 octets

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

Produit la sortie suivante:

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

Les première et dernière lignes de sortie ont un espace de fin. Le code utilise les remplacements de regex et le fait que si les objets ne sont pas définis, ils sont interprétés comme des chaînes (par exemple, FKCIIBAVWMG est traité comme "FKCIIBAVWMG". Impossible de supprimer les guillemets de la dernière ligne en raison de la nouvelle ligne précédente, ce qui Je ne pouvais pas me retrouver ailleurs.

Édition 1: 3 octets enregistrés en remplaçant " "par $", supprimant les parenthèses externes et en insérant un espace après l'impression, puis en supprimant les parenthèses $"x19et en ajoutant un espace après (pour .éviter qu'elles ne soient interprétées comme des décimales)

— Gabriel Benamy
source
Vous pouvez toujours sauvegarder quelques octets: s/(.)/\1 / peuvent être remplacés par s/./$& /. Déposez le dernier point-virgule. Utilisez sayau lieu de print(pour cela, vous devrez soit ajouter, -M5.010soit utiliser à la -Eplace de -e, mais les deux sont gratuits (voir ici )). Newlines littérales au lieu de \n.
— Dada
2

Python 2, 116 octets

Plutôt simple, quelle que soit la raison, même si le remplacement d'une chaîne est si prolixe que c'était la meilleure chose que je pouvais trouver. Peut-être en utilisantre pourrait être plus courte.

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)
— Kade
source
print'F K C I I B A V W M G\nN@P\nT@N\nC@C\nS@P\nP@S\nV@C\nS@P\nE@L\nS@B\nJ C V C O R I B C M G'.replace('@',' '*19)est également 116 octets sans utiliser rejoindre si vous voulez être plus simple. Sinon, 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)115 octets si les espaces de fin sont autorisés. (L'argument à remplacer est "!", Au lieu de "!".)
— MichaelS
2

Lot, 171 octets

@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
— Neil
source
2

Langue GameMaker, 148 octets

Je sais que c'est assez basique, mais je ne pense pas que cela puisse être battu en GML ...

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 "
— Timtech
source
1
Merci @NiCkNewman, mais je l'ai déjà utilisé plusieurs fois sur ce site - codegolf.stackexchange.com/search?q=GameMaker
— Timtech
Je vois, je pensais faire quelque chose dans le GDScriptlangage du Godotmoteur de jeu. Mais, je ne suis pas sûr que ça irait :)
— NiCk Newman
Ah, si seulement le tableau était plus grand; string_repeat(" ",19)est la même longueur que " ".
— u54112
1
@NiCkNewman Ça devrait aller, dites-moi si vous en écrivez :)
— Timtech
@ lastresort Je sais ... Le GML permet des trucs pour casser des choses ensemble mais ses commandes sont si verbeuses ...
— Timtech
2

Pépin , 64 octets

63 octets de code, +1 pour le -Sdrapeau.

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

Essayez-le en ligne!

Explication

Opérateurs utilisés:

  • . (binaire) concatène (fonctionne élément par liste sur les listes).
  • X(binaire) chaîne-multiplie. ( sest une variable pré-initialisée à " ".)
  • ^ (unaire) divise une chaîne en une liste de caractères.
  • .*est un autre moyen de diviser une chaîne en caractères. Il consiste en unary ., qui est un no-op sur des chaînes, couplé avec le *méta-opérateur, qui mappe un opérateur unaire sur chaque élément de son opérande (itérable). L'utilisation .*"..."nous permet de sauvegarder un octet (^"...")- les parenthèses seraient nécessaires car la .priorité est plus grande que ^.
  • PEajoute un élément à une liste. AEajoute un élément à une liste.

Sur cette base, voici le code étape par étape:

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

Lorsque ce résultat est imprimé automatiquement, l' -Sindicateur joint les sous-listes des espaces et la liste principale des nouvelles lignes, donnant ainsi le résultat souhaité.

— DLosc
source
2

C, 171 156 octets

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

Affiche également un caractère de fin de ligne suivant ... Peut-être encore mieux joué au golf.

— cleblanc
source
2

Perl 5, 92 86 octets

  • 6 octets sauvés grâce à Dada

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

Utilisations sprintf, remplissage et opérateur de répétition de chaîne x.

— simbabque
source
Belle solution. \nToutefois, vous pouvez économiser quelques octets: remplace par des passages à la ligne littéraux, vous n'avez pas besoin d'espaces entre l' xopérateur et le nombre qui suit, et remplacez enfin split//,xxxpar xxx=~/./g.
— Dada
1

Haskell, 128 125 114 octets

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

Essayez-le ici

  • ((:" ")=<<)is concatMap (\a -> [a,' '])- les pads en ajoutant un espace derrière chaque lettre de son entrée
— Angs
source
1

Powershell, 95 octets

Inspiré par la réponse de @ AdmBorkBork .

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

Explication

Le premier opérateur remplaçant crée le rectangle 11x11.

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

Le deuxième opérateur remplaçant insère un espace après chaque caractère. Le résultat a des espaces de fin.

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
— mazzy
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.