Pegue uma carona na Reading, se você passar em Go, colete US $ 200

39

Conselho de Monopólio

Para este desafio do código-golfe, estaremos construindo o jogo de tabuleiro Monopoly.

Regras:

  • Não aceite nenhuma entrada.
  • Crie uma placa 11x11, em que cada caractere ASCII que forma a placa é a primeira letra de cada espaço da versão americana da placa Monopoly.
  • Os caracteres devem ser separados por espaços.
  • Go deve começar no canto inferior direito.

A string exata a ser produzida é

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 

Observe que da parte inferior direita para a esquerda inferior os quadrados são os seguintes:

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

Editar Uau! vocês com certeza gostaram deste! :)

jacksonecac
fonte
7
Eu não pretendo ser um defensor, mas ... como alguém passa Go enquanto avançava para o Boardwalk?
SP3000
4
Se você está no calçadão :)
jacksonecac
8
Que você não pode obter um cartão de oportunidade se você estiver em calçadão :(
jacksonecac
27
Eu falhei com todos vocês
jacksonecac 19/10/2016
3
São permitidos espaços à direita?
19416 Adnan

Respostas:

36

Retina , 74 bytes


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

1

A terceira a última e a última linha devem conter um único espaço.

Experimente online!

Explicação


FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG

Isso substitui a entrada (vazia) pela string na segunda linha.

S_`(._.)

Este é um estágio dividido, que divide a cadeia de caracteres em torno das correspondências da expressão regular (._.)(ou seja, quaisquer três caracteres com um _no meio). A razão pela qual colocamos toda a regex em um grupo é que os estágios divididos também retornam os resultados da captura de grupos. Por exemplo, dividir abcdao redor bc[a, d], mas dividir ao redor b(c)[a, c, d]. Dessa forma, obtemos todas as ._.partes em linhas separadas, mas também as partes de 11 caracteres no início e no final. Usamos a _opção para omitir resultados vazios entre as ._.correspondências individuais . O resultado seria este:

FKCIIBAVWMG
N_P
T_N
C_C
S_P
P_S
V_C
S_P
E_L
S_B
JCVCORIBCMG

Em seguida, processamos os sublinhados:

_
9$*

Isso substitui cada sublinhado por nove 1s. A razão pela qual usamos 1s aqui em vez de espaços imediatamente é que facilita a inserção dos espaços de preenchimento a seguir.

\B

Lembre-se de que há um espaço na segunda linha. Isso insere um espaço em todas as posições que não são um limite de palavras, ou seja, em todos os lugares, exceto no início e no final das linhas.

1

E, finalmente, substituímos todos esses 1s por espaços também.

Martin Ender
fonte
1
Bom trabalho! Isso foi rápido!
21416 jacksonecac
39
+1 para (._.).
Destrutível Lemon
^ Estava prestes a dizer que ahha
jazzboy
25

Geléia , 44 bytes

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

Experimente online!

Idéia

Se removermos cada segunda coluna e transpormos linhas com colunas, obteremos o quadro a seguir.

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

Agora, podemos girar cada coluna uma unidade para a direita, movendo todos os espaços restantes para a direita.

JFNTCSPVSES
KC         
CV         
IC         
IO         
BR         
AI         
VB         
WC         
MM         
GGPNCPSCPLB

Então, nós remover os espaços restantes e substituir linefeeds com a letra D .

JFNTCSPVSESDCKDVCDCIDOIDRBDIADBVDCWDMMDGGPNCPSCPLB

Agora, substituímos cada letra pelo seu índice baseado em 1 no alfabeto.

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

Em seguida, convertemos essa matriz de dígitos da base bijetiva 23 para inteiro.

54580410997367796180315467139871590480817875551696951051609467717521

Agora, convertemos esse número inteiro em base bijetiva 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

Finalmente, usamos esses dígitos para indexar na página de códigos de Jelly .

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

Esses são os dados codificados que incluiremos no programa ( 29 bytes ). Para produzir a saída desejada, basta reverter as etapas acima.

Código

“£ċ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
fonte
5
Obrigado pela explicação detalhada. É sempre interessante ver o processo por trás das respostas para codificar perguntas sobre golfe. :)
XtraSimplicity
11
Código Golf - onde é perfeitamente normal ver um número na base de 250 e base 23.
corsiKa
Técnica de compressão agradável. Por que a transposição é necessária?
ETHproductions
@ETHproductions Jelly não tem um átomo de preenchimento, então posso preencher manualmente todas as linhas com espaços do mesmo comprimento ou usar o zip diádico ( z) com um preenchimento.
Dennis
16

05AB1E , 48 47 bytes

Agradecemos a Emigna por salvar um byte!

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

Explicação:

Primeiro alguma compressão. •(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•é uma versão compactada do seguinte número:

120860198958186421497710412212513392855208073968557051584380118734764403017

Depois disso, isso é convertido na base 33 , o que resulta na seguinte sequência:

FKCIIBAVWMGN0PT0NC0CS0PP0SV0CS0PE0LS0BJCVCORIBCMG

Os zeros são substituídos por 9 espaços , usando o código a seguir ¾9ð×:. Depois disso, Sdividimos a string em caracteres e os dividimos em pedaços de 11 elementos (terminados com 11ô). Temos a seguinte matriz bidimensional:

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

Nós gridify essa matriz com »e sua saída será implicitamente.

Usa a codificação CP-1252 . Experimente online!

Adnan
fonte
3
A compactação com 0 em vez de D salva um byte•(K·;“…¬È¦z"9äuŸé;TÞîÕs‡ÓÐV9XÒt\<•33B¾9ð×:S11ô»
Emigna 19/10/16
@ Emigna Ah, isso é inteligente! Obrigado :).
19416 Adnan
12

Python 2, 89 bytes

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

Cria o modelo

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

para substituir em letras por formatação de string. O modelo usa dois tipos de linhas:

  • A linha externa lde 11 cópias de letra mais espaço e, em seguida, uma nova linha. Também é usado para a primeira e a última linha. Tem um espaço à direita.
  • A linha interna de um caractere, depois um caractere precedido por 19 caracteres de espaços de preenchimento e, em seguida, uma nova linha. É copiado 9 vezes para as linhas centrais.

O Python 3.5 pode salvar um byte com a descompactação da tupla (*'...',).

xnor
fonte
1
Mudar para o Python 3.5 deve salvar um byte.
Dennis
9

PowerShell v2 +, 131 123 114 110 99 bytes

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

Esta é apenas uma string literal com novas linhas colocadas no pipeline, com um pouco -replaceno final para transformar 0em 19espaços. A primeira e a última linha são literalmente. Com apenas 10 espaços e pouca repetição, não havia espaço suficiente para jogar golfe. Essa sequência é deixada no pipeline e a saída via implícita Write-Outputacontece na conclusão do programa.

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
fonte
9

Javascript ES6 REPL , 105 102 101 bytes

Não há muita coisa interessante acontecendo aqui. Cole no console para ver os resultados desejados

Guardou 3 bytes graças a @Arnauld Guardou
mais 1 byte graças a @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))

Bassdrop Cumberwubwubwub
fonte
Não acho que o REPL seja permitido.
NoOneIsHere
1
Eu consegui raspar outro byte. Substitua as 1s com espaços e usar esta expressão regular em vez disso:.replace(/.( ?)/g,`$& `+`$1`.repeat(17))
Neil
Uma maneira diferente de raspar outro byte é substituir as 1s com espaços e utilizar esta função em vez disso:a=>a-1?a.repeat(18):a+' '
ETHproductions
@ Neil obrigado, adoro a sua abordagem!
você precisa saber é o seguinte
7

/// , 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 

Experimente online!

Por alguma razão misteriosa, parece haver espaços à direita após o Gs. Sem eles, meu código teria 96 bytes.

Agradecimentos a 42545 (ETHproductions) e 56258 (daHugLenny) por reduzir 1 byte cada!

Erik, o Outgolfer
fonte
@ETHproductions Link errado, talvez? Não consigo salvar nenhum byte como esse.
Erik the Outgolfer
Não são 98 bytes se você remover o espaço após os Gna primeira e na última linha?
Emigna
1
@ Emigna Toda a discussão sobre os espaços extras.
Erik the Outgolfer
1
@ Emigna eu sei, mas a saída exata os contém, então não os removerei.
Erik o Outgolfer
Meu mal, tente isso .
ETHproductions
6

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

Experimente online

>gira tartaruga, "foo"escreve cordas na grade. o último "foi elidável

Limão destrutível
fonte
5

V , 75, 62 , 59 bytes

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

Experimente online!

Como este codel contém caracteres não ASCII, aqui está um 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..../& 

Explicação. Primeiro, inserimos o seguinte texto:

FKCIIBAVWMG
NPTNCCSPPSVCSPELSB
JCVCORIBCMG

Então, <esc>voltamos ao modo normal. Neste ponto, o cursor está na terceira linha na última G. Convenientemente, existe um comando para nos colocar na primeira coluna da linha logo acima do cursor. Esse comando é -. Então, quando terminarmos na segunda linha (na N), executamos o seguinte loop:

ò9á lli
ò

Explicação:

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

Agora, o buffer fica assim:

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

Agora usamos um regex compactado para substituir cada caractere por esse caractere e um espaço. Essa é a Í./&parte. Isso se traduz no seguinte regex do vim:

:%s/./& /g

Que significa:

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

R, 149 146 bytes

Não é tão impressionante, mas também não tenho certeza de como isso seria jogado no golfe. Explorar de pastealguma forma é o meu primeiro palpite. Compare com o texto bruto de 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-violino

Billywob
fonte
4

Python 2, 108 bytes

Um pouco diferente da outra resposta python, sem substituições, apenas junções de strings.

print'\n'.join(map(' '.join,['FKCIIBAVWMG']+map((' '*9).join,zip('NTCSPVSES','PNCPSCPLB'))+['JCVCORIBCMG']))
TFeld
fonte
1
Eu sabia que zip era o caminho a seguir! Tinha praticamente a mesma solução até 118 mais cedo e estava indo para o golfe esta noite. Eu estava sentindo falta do mapa. Acho que você me venceu. 1
ElPedro 19/10
4

Perl, 90 bytes

Abordagem bastante chata, não consegue pensar em uma maneira melhor de reduzir ... Requer -Esem custo adicional. Gera um espaço adicional no final de cada linha. -2 bytes graças a @Dada !

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

Uso

perl -E 'say"FKCIIBAVWMG
NZP
TZN
CZC
SZP
PZS
VZC
SZP
EZL
SZB
JCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'
Dom Hastings
fonte
2 bytes mais curto (mas basicamente o mesmo código que você): perl -E 'say"FKCIIBAVWMG\nNZP\nTZN\nCZC\nSZP\nPZS\nVZC\nSZP\nEZL\nSZB\nJCVCORIBCMG"=~s/Z/$"x9/ger=~s/./$& /gr'. (Substitua \npor novas linhas literais para chegar a 90).
Dada
@ Dadá Ahhh, muito melhor! Obrigado!
Dom Hastings
"very nice" teria encontrado uma solução de 40 bytes, mas obrigado: D
Dada
4

Jolf, 72 bytes

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

Substitua tudo por \x05, ou tente aqui!

Ζ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

Isso fornece a string desejada.

Conor O'Brien
fonte
3

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 graças a @BassdropCumberwubwubwub .
-11 bytes graças a @Numberknot .

Ungolfed & código de teste:

Experimente aqui.

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

Saída:

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
fonte
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);}para 150 (nota que Stackexchange remove espaços excessivos)
Bassdrop Cumberwubwubwub
@BassdropCumberwubwubwub Umm .. isso gera apenas 3 espaços entre as 'paredes verticais', em vez de 19 .. Aqui está uma ideona do seu código.
Kevin Cruijssen
Daí a minha nota, deve haver mais espaços, smas a stackexchange os removeu. Aqui está o ideone , agora mesmo em 142 bytes
Bassdrop Cumberwubwubwub
@BassdropCumberwubwubwub Ah ok. Não sabia que você estava entre os s=" ". Nesse caso, é realmente mais curto. E .‌​replace(""," ").replace("_",s);pode ser .replace("_",s).‌​replace(""," ");em vez de um adicional de -8 bytes
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 19/10/16
3

Befunge, 120 bytes

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

A primeira linha tem a sequência a ser impressa ao contrário (parece que não é, mas o código está retornando nessa linha). A segunda linha imprime as linhas superior e inferior. A terceira linha e o lado esquerdo da quarta linha imprimem as linhas do meio, e o pequeno pedaço no canto inferior direito faz uma coisa interessante: move o cursor de volta para a segunda linha para imprimir a última linha, mas depois de terminar, sai.

Como você pode ver na primeira linha, as cadeias são separadas por espaços para distinguir entre a primeira, a média e a última. Os espaços podem ser qualquer outra coisa, e se eu usasse caracteres ASCII de 0 a 9, poderia facilmente salvar 4 bytes. O $ que você vê é apenas um caractere de lixo que precisa estar lá e pode ser substituído por qualquer coisa, menos um espaço.


fonte
3

J, 77 73 bytes

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

Observe que 43 bytes, mais da metade do total, são usados ​​apenas para a sequência ' FKCIIBAVWMGNPTNCCSPPSVCSPELSBJCVCORIBCMG'.

Explicação

Primeiro, faça uma lista

   |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

Então faça a sua tabuada

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

Em seguida, teste a igualdade com zero

   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

Achate, encontre as somas cumulativas e multiplique elemento

   ,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

Em seguida, junte-se aos zeros, divida-o em sublistas de comprimento 22, solte a cabeça de cada sub-lista e use os valores como índices na string ' 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
milhas
fonte
O melhor que eu poderia obter usando a compactação genérica de strings é de 90 bytes:(' ',@,.~]);._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 Sim, é difícil usar a compactação de strings em J quando outros idiomas têm dicionários e compactação embutida.
miles
@ ConorO'Brien Tentei jogar um pouco mais a sua idéia e cheguei a 76 bytes_11,@,.&' '\'FKCIIBAVWMGN_PT_NC_CS_PP_SV_CS_PE_LS_BJCVCORIBCMG'rplc'_';9#' '
miles
3

Na verdade , 74 bytes

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

Experimente online!

Este programa funciona com o mesmo princípio básico da resposta Python 2 do xnor .

Explicação (novas linhas substituídas \npor uma questão de clareza):

"%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
fonte
3

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

Sem espaço à direita; sem seguir a nova linha.

Uma solução simples. Comece com a string literal. Replace !por 9 espaços. Depois, Splitem 11 cordas por ~e mais para chars (interior Select). Acrescente um espaço a cada caractere e depois Joinvolte para 11 strings. Finalmente outro Joinpor caractere de nova linha.

Ng do link
fonte
3

Ruby, 92

Programa completo, imprime no stdout usando $> <<

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

Existem 40 cartas no total para traçar. As letras 10 a 28 alternam entre ser seguido por uma nova linha ou ' '*19. As letras anteriores e posteriores são separadas por espaços únicos.

Level River St
fonte
3

Perl, 115 112 bytes

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

Produz a seguinte saída:

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 

A primeira e a última linha de saída têm um espaço à direita. O código utiliza substituições de regex e o fato de que, se os objetos não forem definidos, eles serão interpretados como seqüências de caracteres (por exemplo, FKCIIBAVWMG é tratado como "FKCIIBAVWMG". Não foi possível excluir as aspas da última linha devido à nova linha anterior, que Eu não poderia procurar em nenhum outro lugar.

Editar 1: salvou 3 bytes, substituindo " "por $", removendo os parênteses externos e inserindo um espaço após a impressão, removendo os parênteses ao redor $"x19e adicionando um espaço posteriormente (para .que não seja interpretado como decimal)

Gabriel Benamy
fonte
Você ainda pode salvar alguns bytes: s/(.)/\1 /pode ser substituído por s/./$& /. Solte o ponto e vírgula final. Use em sayvez de print(para isso, você precisará adicionar -M5.010ou usar em -Evez de -e, mas ambos são gratuitos (veja aqui )). Novas linhas literais em vez de \n.
Dada
2

Python 2, 116 bytes

Bem simples, por qualquer motivo, mesmo que a substituição de strings seja tão detalhada, foi a melhor coisa que eu pude criar. Possivelmente usando repode ser mais curto.

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
fonte
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)também tem 116 bytes sem usar junção se você quiser ser mais direto. Como alternativa, 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)são 115 bytes se o espaço em branco à direita for permitido. (O argumento para substituir é, em vez de '!' '!'.)
Michaels
2

Lote, 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
Neil
fonte
2

Idioma do GameMaker, 148 bytes

Eu sei que é bastante básico, mas não acho que isso possa ser superado no 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
fonte
1
Obrigado @NiCkNewman, mas eu já o usei antes neste site algumas vezes - codegolf.stackexchange.com/search?q=GameMaker
Timtech 22/16
Entendo, eu estava pensando em fazer um pouco da GDScriptlinguagem do Godotmecanismo de jogo. Mas, não tenho certeza se seria ok :)
NiCk Newman
Ah, se o quadro fosse maior; string_repeat(" ",19)tem o mesmo comprimento que " ".
U54112
1
@NiCkNewman Isso deve ficar bem, me diga se você escrever alguma :)
Timtech
@lastresort eu sei ... GML permite truques com quebrando coisas juntos, mas seus comandos são tão detalhado ...
Timtech
2

Pip , 64 bytes

63 bytes de código, +1 para -Ssinalizador.

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

Experimente online!

Explicação

Operadores utilizados:

  • . (binário) concatena (opera item em listas).
  • X(binário) string-multiplica. ( sé uma variável pré-inicializada para " ".)
  • ^ (unário) divide uma sequência em uma lista de caracteres.
  • .*é outra maneira de dividir uma string em caracteres. Consiste em unário ., que é um não-op em cadeias, emparelhado com o *meta-operador, que mapeia um operador unário para cada item em seu operando (iterável). O uso .*"..."permite salvar um byte em excesso (^"...")- os parênteses seriam necessários porque .tem maior precedência que ^.
  • PEprecede um elemento a uma lista. AEanexa um elemento a uma lista.

Com esse pano de fundo, aqui está o código passo a passo:

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

Quando esse resultado é impresso automaticamente, o -Ssinalizador une as sublistas nos espaços e a lista principal nas novas linhas, fornecendo a saída desejada.

DLosc
fonte
2

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

Também gera um caractere de linha nova à direita ... Provavelmente poderia ser um pouco mais complicado.

cleblanc
fonte
2

Perl 5, 92 86 bytes

  • economizou 6 bytes graças ao Dada

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

Usos sprintf, preenchimento e o operador de repetição de string x.

simbabque
fonte
Ótima solução. Porém, você pode salvar alguns bytes: substitui \npor novas linhas literais, não precisa de espaços entre o xoperador e o número a seguir e, finalmente, substitui split//,xxxpor xxx=~/./g.
Dada
1

Haskell, 128 125 114 bytes

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

Experimente aqui

  • ((:" ")=<<)is concatMap (\a -> [a,' '])- almofadas adicionando um espaço atrás de cada letra em sua entrada
Angs
fonte
1

PowerShell, 95 bytes

Inspirado na resposta de @ AdmBorkBork .

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

Explicação

O primeiro operador de substituição cria o retângulo 11x11.

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

O segundo operador de substituição insere um espaço após cada caractere. O resultado possui espaços à direita.

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
confuso
fonte