55

Em Haskell, a notação de lista:

[a,b,c]

É apenas açúcar sintático para:

a:b:c:[]

E a notação de string:

"abc"

É apenas açúcar sintático para:

['a','b','c']

Isso significa que a string:

"abc"

É o mesmo que:

'a':'b':'c':[]

Tarefa

Dada uma string, você deve exibir a aparência da versão des-sintaxe em Haskell.

Regras

Você receberá uma string por qualquer método de entrada válido. Você deve enviar uma string que termina :[]com todos os caracteres da entrada cercada 'e separada por :. A cadeia vazia deve ser exibida [].
Você pode assumir que não receberá caracteres que exijam escape (por exemplo ', novas linhas, guias ...) e que a entrada estará no intervalo ascii imprimível
Este é um código-golf, você deve procurar minimizar a contagem de bytes de sua resposta

Casos de teste

"" -> []
"a" -> 'a':[]
"Hello, World" -> 'H':'e':'l':'l':'o':',':' ':'W':'o':'r':'l':'d':[]

— Assistente de Trigo
fonte

A entrada terá valores não-ascii? Sua restrição de caracteres que exigem escape exige que saibamos quais caracteres Haskell escapará ou pressuponha que sua lista seja completa.

— FryAmTheEggman

@FryAmTheEggman Você pode supor que eles estejam na faixa ascii #

— Wheat Wizard

7

@totallyhuman Esses nem são válidos Haskell. Se eles eram talvez, mas legais, não são, definitivamente não.

— Wheat Wizard

38

Esta pergunta pode ser alternativamente intitulada "Diet Haskell".

— March Ho

11

@cairdcoinheringaahing Não, "e 'são sintaticamente diferentes.

— Assistente de trigo

85

Haskell , 26 bytes

(++"[]").((++":").show=<<)

Experimente online!

Explicação:

Em notação sem ponto e usando em concatMapvez de =<<, isso se torna

f s = concatMap(\c-> show c ++ ":")s ++ "[]"

Dada uma string s, mapeamos cada caractere cpara uma string "'c':"usando a showfunção que retorna uma representação de string da maioria dos tipos Haskell. Essas cadeias são concatenadas e uma final []é anexada.

Embora não seja solicitada pelo desafio, essa resposta funciona até com escape adequado, pois showcuida dela: f "'"cede "'\\'':[]".

— Laikoni
fonte

25

Espere um minuto, você quer dizer (++'[':']':[]).((++':':[]).show=<<), não?

— Adám

11

Quando qualquer desafio tem uma resposta de Haskell, eu a voto por princípio. Isso vale o dobro para este.

— Re

43

Haskell, 33 28 26 bytes

foldr((.(':':)).shows)"[]"

Experimente online!

folda função pointfree fornecida da direita para a string de entrada começando com []. A função é: mostrar char como um caractere Haskell, ou seja, cercado 'e concatenado com o resultado até agora, depois de colocar um :na frente dele.

Edit: @ Ørjan Johansen salvou dois bytes. Obrigado!

— nimi
fonte

Suponho que isso signifique (++'[':']':[]).(>>= \c->'\'':[]++[c]++'\'':':':[]).

— Adám

11

Eu acho que isso é superior à outra resposta de Haskell (na mesma contagem de bytes) devido ao uso :para criar a lista, e não ++, embora ambos tenham sua própria elegância.

— CAD97

4

Isso é incrível. Duas abordagens separadas que têm o mesmo byte contam no mesmo idioma.

— J Atkins

19

Python 3 , 32 bytes

lambda s:"%r:"*len(s)%(*s,)+"[]"

Experimente online!

— xnor
fonte

17

JavaScript ES6, 42 40 31 bytes

s=>s.replace(/./g,"'$&':")+"[]"

Substitui cada caractere por '<char>':e depois adiciona []ao final

Experimente online!

— Downgoat
fonte

11

Eu amo isso sobre CodeGolf. Nunca soube $&.

— Steve Bennett

16

Lisp comum, 50 42 bytes

(format t"~{'~a':~}[]"(coerce(read)'list))

Experimente online!

Reduzido graças ao comentário de @coredump, usando em readvez de definir uma função.

— Renzo
fonte

11

Bem-vindo ao PPCG!

— Martin Ender

2

Lisp! Bem-vindo, na verdade :)

— Olivier Dulac

@Renzo Hi Renzo, você poderia reduzi-lo um pouco usando uma forma lambda anônimo, ou simplesmente chamando leitura: (format t"~{'~a':~}[]"(coerce(read)'list))(algumas outras perguntas são entradas wrt mais rigorosas e saídas, mas aqui isso é bom)

— coredump

@ Coredump, obrigado !, Atualizei o código.

— Renzo

11

V , 11 bytes

Í./'&':
A[]

Experimente online!

Usa um regex para cercar todos os caracteres de entrada '':e, em seguida, Apende []até o final.

— nmjcman101
fonte

10

C, 55 54 53 bytes

s(char*h){while(*h)printf("'%c':",*h++);puts("[]");}

— Govind Parmar
fonte

11

você pode remover o espaço emchar *h

— Cyoce

11

Em puts("[]");vez disso, você pode fazer a saída com uma nova linha à direita para salvar alguns bytes.

— Kritixi Lithos

recursives(char*h){*h?printf("'%c':",*h++),s(h):puts("[]");}

— l4m2

8

Python 3 , 41 38 36 bytes

^{-2 bytes graças a ovs}

print(*map(repr,input()),[],sep=':')

Experimente online!

— Cajado
fonte

Whoops ... Esqueceu que *mapexiste ...

— Mr. Xcoder

Fiquei intrigado com o vazio input()durante os últimos 20 minutos (literalmente), quando poderia ser apenas um lambda @ @.

— Rod

Entrada vazia funciona?

— Assistente de trigo

@WheatWizard oh, eu estava usando uma entrada vazia-vazia (sem nova linha)

— Haste

Você pode substituir "[]"por[]

— ovs

8

05AB1E , 15 12 11 10 bytes

-3 bytes graças à carusocomputação
-1 byte graças a Adnan
-1 byte graças à idéia genial de Erik the Outgolfer

ʒ"'ÿ':"?},

Experimente online!

ʒ          # Filter out every character that the following code doesn't return 1 for
 "'ÿ':"?   #   Print the string 'ÿ': with ÿ replaced by this character
        }  # End for
         , # No character returned 1 so an empty array is left on the stack. Print that

— Riley
fonte

Aparentemente eu vencê-lo por 4 segundos ;-)

— Digital Trauma

11

@DigitalTrauma O seu apareceu quando eu estava pressionando Postar sua resposta.

— Riley

11

Você pode imprimir a matriz global em vez de pressionar os colchetes com 3 bytes. Você também pode interpolar a seqüência de caracteres para obter mais economias de bytes, para um total de -3, resultado final de 12 bytes:vy"'ÿ':"?}¯?

— Magic Octopus Urn

@carusocomputing Eu uso o interpolador de strings o tempo todo para suítes de teste, mas esqueço de usá-lo no código real. Obrigado!

— Riley

@carusocomputing Eu pensei vy"'ÿ':"}¯Jque funcionaria para 11, mas Jse junta à matriz global, não à pilha inteira nessa situação.

— Riley

8

R, 51 bytes

f<-function(x)(paste0(gsub("(.)","'\\1':",x),'[]'))

— tc
fonte

11

Ótima solução! Algumas maneiras de salvar alguns bytes e realmente resolver isso. A E / S padrão permite que você retorne uma função anônima ou receba a entrada de stdin, a última das quais seria muito mais curta usando em scan(,'')vez de uma função.

— Giuseppe

Obrigado, sou um pouco novato em R (e código golf!), Por isso ainda não compreendi completamente funções anônimas, embora eu estivesse tentando fazê-lo sem 'function' lá. digitalização pode ser útil!

— tc

ah, bem uma função anônima é apenas aquele em que você não atribuir a uma variável que você tinha acabado de deixar cair a f<-partir do início do seu código

— Giuseppe

paste0 (gsub ('(.)', "'\\ 1':", scan (, "")), '[]') tem 43 anos

— Zahiro Mor

8

Pitão, 14 10 8 bytes

j\:a`MQY

Tente isso!

-2 bytes graças a @isaacg

Finalmente, pyth é bom em alguma coisa.

explicação

j\:a`MQY
    `MQ        # map the representation over the input string: ["'a'","'b'",...]
   a   Y       # append the empty list
j\:            # join on :

— KarlKastor
fonte

@isaacg Obrigado! Esqueci Me não sei por que não usei a. Agora somos pelo menos 2 bytes mais curtos que todas as outras soluções aqui!

— KarlKastor

7

Perl 6 , 19 bytes

{S:g|.|'$/':|~'[]'}

— Sean
fonte

7

Retina, 12

3 bytes salvos graças a @FryAmTheEggman

.
'$ &':
$
[]

2 etapas:

para cada personagem restante colocado ' ':ao seu redor
adicionar []até o fim

Experimente online .

— Trauma Digital
fonte

Ajudou o cara que você venceu por 4 segundos a amarrá-lo;).

— Urna Mágica do Polvo

Eu estava pensando nisso!

— CalculatorFeline

6

Python 2 , 48 46 44 37 bytes

-2 bytes graças a Rod. -7 bytes graças ao Assistente de Trigo.

lambda s:':'.join(map(repr,s)+['[]'])

Experimente online!

— totalmente humano
fonte

11

Um pouco mais curto

— Wheat Wizard

Oh, legal. Obrigado!

— totallyhuman

11

Um mais curto como lambda s:':'.join(map(repr,[*s,[]]))ou lambda s:':'.join(map(repr,s))+":[]".

— xnor

@xnor O segundo exemplo que você dá parece não funcionar para o caso vazio. (a resposta original parecia muito semelhante a isso, mas pago muito para cobrir o caso string vazia)

— Assistente de trigo

6

Befunge , 29 27 bytes

<,,,,\_v#`0:~"'':"
@,,"[]"<

Experimente online!

6

JavaScript (ES6), 36 bytes

s=>s?`'${[...s].join`':'`}':[]`:"[]"

Tente

f=
s=>s?`'${[...s].join`':'`}':[]`:"[]"
oninput=_=>o.innerText=f(i.value);o.innerText=f(i.value="abc")

<input id=i><pre id=o>

Expandir snippet

— Shaggy
fonte

5

Geléia , 11 10 8 bytes

-1 byte graças a Christian (remova a concatenação ;e utilize impressão implícita)

+0 bytes (corrigido para o caso limite de uma cadeia vazia - anteriormente o programa completo: ŒṘ€j”:“:[])

-2 graças a Erik, o Outgolfer (use pno lugar de ;€desde que ”:é efetivamente comprimento 1; use Ø[desde que se tornou abreviado para ⁾[])

ŒṘ€p”:Ø[

Experimente online!

Um programa completo que imprime o resultado (como um link, ele retorna uma lista de listas de caracteres).

... mas existe uma maneira de economizar usando o STDIN?

Quão?

ŒṘ€p”:Ø[ - Main link: list of characters, s  e.g. "Hey"
ŒṘ€      - Python representation for €ach    [["'",'H',"'"],["'",'e',"'"],["'",'y',"'"]]
    ”:   - literal character = ':'
   p     - Cartesian product                 [["'",'H',"'",':'],["'",'e',"'",':'],["'",'y',"'",':']]
         - implicit print (no newline): 'H':'e':'y':
      Ø[ - literal list of characters        ['[',']']
         - implicit print (no newline): []

— Jonathan Allan
fonte

4

PHP , 41 bytes

<?=preg_filter("#.#","'$0':",$argn)."[]";

Experimente online!

— Jörg Hülsermann
fonte

4 bytes mais curto: for(;~$c=$argn[$i++];)echo"'$c':"?>[].

— user63956

@ user63956 não precisa de mais <?com qual opção deve ser executada? Faça uma abordagem própria, eu diria que, para obter

— votos positivos e títulos

Funciona com a -Rbandeira. As tags podem ser fechadas mesmo em construções como eval()e create_function().

— user63956

4

Perl 5 , 22 bytes

19 bytes de código + -psinalizador.

s/./'$&':/g;$\="[]"

Ou, pelo mesmo bytecount s/./'$&':/g;s/$/[]/,.

Para a frente: s/./'$&':/genvolve cada caractere entre aspas e adicione um :depois. $\é impresso implicitamente após cada impressão, portanto, defina-o como []saída final [].

Experimente online!

— dada
fonte

4

Java (OpenJDK 8) ,86 83 76 bytes

-3 bytes graças a @KevinCruijssen
-7 bytes graças a @FlorianSchaetz

s->{String b="";for(char c:s.toCharArray()){b+="'"+c+"':";};return b+"[]";};

Experimente online!

— Beluga Bashful
fonte

Você pode soltar 4 bytes. O final ;não precisa ser contado para respostas lambda, o ;depois do }não é necessário e o {e }pode ser removido em torno do loop for. E você poderia economizar mais 4 bytes em Java 10 mudando tanto o Stringe chara var.

— Kevin Cruijssen

4

brainfuck, 68 bytes

+[-->+[<]>-]>>,[<.>.<.>>-[>+<+++++++++]>+.[-]<<,]-[+[+<]>>+]<+++.++.

Experimente online!

— daniero
fonte

Não funciona bem com a sequência vazia - retornou dois caracteres inválidos no seu teste online. Muito bom, caso contrário.

— NoseKnowsAll

@NoseKnowsAll Parece que não consigo replicar isso; Sem entrada, não recebo saída. Você poderia fornecer um link atualizado com essa entrada?

— Daniero 15/06

Isto é o que recebi quando o executo :. Com uma entrada vazia, ele deve retornar "[]" sem as aspas.

— NoseKnowsAll

@NoseKnowsAll Seu link vai para a entrada "olá mundo" (obtenha um link atualizado pressionando o botão de link / cadeia), mas sim, entendi o que você quer dizer. Vou dar uma olhada nisso #

— daniero 15/06

11

@NoseKnowsAll Lá vai você, eu o

— consertei

3

Flak cerebral , 135 , 131 bytes

{({}<>)<>}(((((((()()()()()){})){}{}())){}{})[()()])<>{<>(((((((()()()){}()){}){}()){})[(((()()()){})){}{}()])<>)({}<({}<>)>)<>}<>

Experimente online!

+1byte para a -cbandeira.

Agradeço ao WheatWizard por remover NOOPs muito óbvios que eu tinha sem motivo XD.

— DJMcMayhem
fonte

@WheatWizard> _> Sim, eu estava apenas testando você ... Hahaha, obrigado por apontar isso. Vou tentar golf-lo mais tarde, mas vou acrescentar que agora lol

— DJMcMayhem

3

ML padrão , 52 50 bytes

Guardado 2 bytes graças a @Laikoni!

fn s=>String.translate(fn c=>"'"^str c^"':")s^"[]"

Experimente online!

String.translateé um nome infelizmente muito tempo, mas foi de 5 bytes menor do que usando concat, mape explode.

— musicman523
fonte

@Laikoni thanks! Eu sempre esqueço que os operadores têm menor precedência do que funções.

— musicman523

3

Cubix , 31 29 bytes

uo@[)o'U);!A?ro;o;o;os:'/u:''

Atambém pode ser substituído i; ~~tentando descobrir se há uma boa maneira de extrair outro byte ou dois disso.~~ -2 bytes graças ao MickyT! Também superado por MickyT !

Encaixa em um cubo 3x3x3:

      u o @
      [ ) o
      ' U )
; ! A ? r o ; o ; o ; o
s : ' / u : ' ' . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Assista online!

Experimente online!

— Giuseppe
fonte

Você pode salvar alguns bytes, usando alguns incrementos para o último colchete. Isso permite que a linha de fundo para ser comprimido um poucouo@[)o'U);!A?ro;o;o;os:'/u:''

— MickyT

2

Python 2 , 47 bytes

lambda a:`list(a)+[[]]`.replace(', ',':')[1:-1]

Experimente online!

— Cajado
fonte

Eu tinha a mesma abordagem, mas não entendi a [1:-1]parte, portanto era mais longa do que totalmente humano. +1

— Assistente de trigo

Estranho que a solução trivial tenha apenas 3 bytes a mais (em Python 3).

— Mr. Xcoder

2

APL (Dyalog) , 21 19 bytes

'[]',⍨'.'⎕R'''&'':'

Experimente online!

'[]',⍨ os colchetes anexados a

'.' todo personagem

⎕R PCRE R substituído com

'''&'':' uma citação, a correspondência, uma citação e dois pontos

— Adão
fonte

2

sed , 19 18 bytes

-1 byte graças à Jordânia

s/./'&':/g;s/$/[]/

Experimente online!

— Una
fonte

2

PHP, 39 bytes

<?while(~$c=$argn[$i++])echo"'$c':"?>[]

Corra como cano com -F.

— Titus
fonte

2

Convexo , 10 bytes

{`':`}%"[]

Experimente online!

— GamrCorps
fonte

2

Cubix , 27 bytes

uosW?U.iv":'"^soso;os@o[]'/

Experimente online!

      u o s
      W ? U
      . i v
" : ' " ^ s o s o ; o s
@ o [ ] ' / . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Assista correr

Uma variação ligeiramente diferente da resposta de Guiseppe . Isso coloca dois pontos e aspas na pilha. Em seguida, percorre a entrada, trocando e produzindo a pilha. Somente a entrada é descartada e os dois pontos e as aspas são mantidos.

Quando o final da entrada é alcançado, o IP se pergunta um pouco ao redor do cubo, adicionando e produzindo os colchetes. Existem alguns comandos redundantes no mix.

— MickyT
fonte

Sintaxe sem açúcar

Tarefa

Regras

Casos de teste

Haskell , 26 bytes

Haskell, 33 28 26 bytes

Python 3 , 32 bytes

JavaScript ES6, 42 40 31 bytes

Lisp comum, 50 42 bytes

V , 11 bytes

C, 55 54 53 bytes

Python 3 , 41 38 36 bytes

05AB1E , 15 12 11 10 bytes

R, 51 bytes

Pitão, 14 10 8 bytes

explicação

Perl 6 , 19 bytes

Retina, 12

Python 2 , 48 46 44 37 bytes

Befunge , 29 27 bytes

JavaScript (ES6), 36 bytes

Tente

Geléia , 11 10 8 bytes

Quão?

PHP , 41 bytes

Perl 5 , 22 bytes

Java (OpenJDK 8) ,86 83 76 bytes

brainfuck, 68 bytes

Flak cerebral , 135 , 131 bytes

ML padrão , 52 50 bytes

Cubix , 31 29 bytes

Python 2 , 47 bytes

APL (Dyalog) , 21 19 bytes

sed , 19 18 bytes

PHP, 39 bytes

Convexo , 10 bytes

Cubix , 27 bytes