55

In Haskell la notazione dell'elenco:

[a,b,c]

È solo zucchero sintattico per:

a:b:c:[]

E la notazione di stringa:

"abc"

È solo zucchero sintattico per:

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

Ciò significa che la stringa:

"abc"

Equivale a:

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

Compito

Data una stringa, dovresti visualizzare come sarebbe la versione non sintattizzata in Haskell.

Regole

Riceverai una stringa con qualsiasi metodo di input valido, dovresti generare una stringa che termina :[]con ogni carattere dell'input circondato da 'e separato da :. La stringa vuota dovrebbe essere generata [].
Puoi presumere che non riceverai alcun carattere che richieda la fuga (ad es '. Newline, tab ...) e che l'input sia compreso nell'intervallo ASCII stampabile
Questo è il golf del codice che dovresti mirare a minimizzare il conteggio dei byte della tua risposta

Casi test

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

— Mago del grano
fonte

L'input avrà mai valori non ascii? Le tue restrizioni sui personaggi che richiedono la fuga richiedono che conosciamo quali caratteri Haskell scapperà o supponiamo che la tua lista sia esaustiva.

— FryAmTheEggman,

@FryAmTheEggman Puoi supporre che siano nella gamma ascii

— Wheat Wizard

7

@totallyhuman Quelli non sono nemmeno validi Haskell. Se fossero forse, ma carini non lo sono, sicuramente no.

— Wheat Wizard

38

Questa domanda può essere alternativamente intitolata "Diet Haskell".

— Marzo Ho

1

@cairdcoinheringaahing No "e 'sono sintatticamente diversi.

— Wheat Wizard

85

Haskell , 26 byte

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

Provalo online!

Spiegazione:

In notazione senza punti e usando al concatMapposto di =<<, questo diventa

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

Data una stringa s, mappiamo ogni carattere csu una stringa "'c':"usando la showfunzione che restituisce una rappresentazione in forma di stringa della maggior parte dei tipi di Haskell. Tali stringhe vengono concatenate e []viene aggiunto un finale .

Sebbene non sia richiesta dalla sfida, questa risposta funziona anche con una corretta evasione, perché se showne occupa: f "'"rendimenti "'\\'':[]".

— Laikoni
fonte

25

Aspetta un minuto, vuoi dire (++'[':']':[]).((++':':[]).show=<<), no?

— Adám,

11

Quando una sfida ha una risposta di Haskell, la voto per principio. Questo è doppio per questo.

— Ryan Reich,

43

Haskell, 33 28 26 byte

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

Provalo online!

foldla funzione pointfree data da destra nella stringa di input che inizia con []. La funzione è: mostra char come char di Haskell, cioè circondato 'e concatenato con il risultato finora dopo averlo messo :davanti.

Modifica: @ Ørjan Johansen ha salvato due byte. Grazie!

— Nome del modello
fonte

Suppongo significhi (++'[':']':[]).(>>= \c->'\'':[]++[c]++'\'':':':[]).

— Adám,

1

Penso che questo sia superiore all'altra risposta di Haskell (con lo stesso numero di byte) a causa dell'utilizzo :per costruire l'elenco piuttosto che ++, sebbene entrambi abbiano la loro eleganza.

— CAD97,

4

Questo è piuttosto sorprendente. Due approcci separati che hanno lo stesso numero di byte nella stessa lingua.

— J Atkin,

19

Python 3 , 32 byte

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

Provalo online!

— XNOR
fonte

17

JavaScript ES6, 42 40 31 byte

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

Sostituisce ogni carattere con '<char>':, quindi aggiunge []alla fine

Provalo online!

— Downgoat
fonte

1

Adoro questo di CodeGolf. Non l'ho mai saputo $&.

— Steve Bennett,

16

Lisp comune, 50 42 byte

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

Provalo online!

Ridotto grazie al commento di @coredump, usando readinvece di definire una funzione.

— Renzo
fonte

1

Benvenuti in PPCG!

— Martin Ender,

2

Lisp! Benvenuto davvero :)

— Olivier Dulac,

@Renzo Ciao Renzo, potresti ridurlo un po 'usando un modulo lambda anonimo, o semplicemente chiamando read: (format t"~{'~a':~}[]"(coerce(read)'list))(alcune altre domande sono input e output

— wrtter

@coredump, grazie! Ho aggiornato il codice.

— Renzo,

11

V , 11 byte

Í./'&':
A[]

Provalo online!

Utilizza una regex per circondare ogni carattere di input '':e quindi Atermina []alla fine.

— nmjcman101
fonte

10

C, 55 54 53 byte

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

— Govind Parmar
fonte

1

puoi rimuovere lo spazio inchar *h

— Cyoce il

1

È possibile puts("[]");invece eseguire l'output con una nuova riga finale per salvare alcuni byte.

— Kritixi Lithos,

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

— l4m2

8

Python 3 , 41 38 36 byte

^{-2 byte grazie agli ovs}

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

Provalo online!

— asta
fonte

Whoops ... Dimenticato che *mapesiste ...

— Mr. Xcoder

Sono stato perplesso dal vuoto input()negli ultimi 20 minuti (letteralmente), quando potrebbe essere solo un lambda @. @

— Rod

L'input vuoto funziona?

— Wheat Wizard

@WheatWizard oh, stavo usando un input vuoto-vuoto (no newline)

— Rod

Puoi sostituirlo "[]"con[]

— ovs il

8

05AB1E , 15 12 11 10 byte

-3 byte grazie al calcolo automatico
-1 byte grazie ad Adnan
-1 byte grazie all'idea geniale di Erik the Outgolfer

ʒ"'ÿ':"?},

Provalo 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

Apparentemente ti ho battuto di 4 secondi ;-)

— Digital Trauma

1

@DigitalTrauma Il tuo è apparso mentre stavo premendo Pubblica la tua risposta.

— Riley,

1

È possibile stampare l'array globale invece di spingere le parentesi con 3 byte. Puoi anche interpolare la stringa per un altro risparmio di byte per un totale di -3, risultato finale 12 byte:vy"'ÿ':"?}¯?

— Magic Octopus Urn

@carusocomputing Uso sempre l'interpolatore di stringhe per le suite di test, ma dimentico di usarlo nel codice reale. Grazie!

— Riley,

@carusocomputing Ho pensato che vy"'ÿ':"}¯Javrebbe funzionato per 11, ma Junisce l'array globale, non l'intero stack in quella situazione.

— Riley,

8

R, 51 byte

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

— tc
fonte

1

Bella soluzione! In alcuni modi è possibile salvare alcuni byte e farlo scendere davvero. l'I / O predefinito ti consente di restituire semplicemente una funzione anonima o persino di ricevere input da stdin, quest'ultimo che sarebbe molto più breve usando scan(,'')invece di una funzione.

— Giuseppe,

Grazie, sono un po 'un novellino con R (e il codice golf!), Quindi non ho ancora capito bene le funzioni anonime, anche se stavo cercando di farlo senza "funzione". la scansione potrebbe essere utile!

— TC

ah, beh, una funzione anonima è solo una in cui non la si assegna a una variabile, quindi si dovrebbe semplicemente abbandonare f<-dall'inizio del codice

— Giuseppe

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

— Zahiro Mor,

8

Pyth, 14 10 8 byte

j\:a`MQY

Prova questo!

-2 byte grazie a @isaacg

Infine, pyth è bravo in qualcosa.

spiegazione

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 Grazie! Mi sono dimenticato Me non so perché non l'ho usato a. Ora abbiamo almeno 2 byte in meno rispetto a tutte le altre soluzioni qui!

— KarlKastor,

7

Perl 6 , 19 byte

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

— Sean
fonte

7

Retina, 12

3 byte salvati grazie a @FryAmTheEggman

.
'$ &':
$
[]

2 fasi:

per ogni personaggio rimanente messo ' ':attorno ad esso
aggiungere []alla fine

Provalo online .

— Trauma digitale
fonte

Ho aiutato il ragazzo che hai battuto per 4 secondi a legarti;).

— Magic Octopus Urn

Ci stavo pensando!

— Calcolatrice

6

Python 2 , 48 46 44 37 byte

-2 byte grazie a Rod. -7 byte grazie a Wheat Wizard.

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

Provalo online!

— totallyhuman
fonte

1

Leggermente più corto

— Mago del grano

Oh, pulito. Grazie!

— totalmente umano il

1

Uno più corto come lambda s:':'.join(map(repr,[*s,[]]))o lambda s:':'.join(map(repr,s))+":[]".

— xnor

@xnor Il secondo esempio che dai non sembra funzionare per il caso vuoto. (la risposta originale sembrava molto simile a quella ma pagava molto per coprire il caso di stringa vuota)

— Wheat Wizard

6

Befunge , 29 27 byte

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

Provalo online!

6

JavaScript (ES6), 36 byte

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

Provalo

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

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

Espandi frammento

— ispido
fonte

5

Gelatina , 11 10 8 byte

-1 byte grazie a Christian (rimuovi la concatenazione ;e utilizza invece la stampa implicita)

+0 byte (fissati per caso limite di una stringa vuota - precedentemente il programma completo: ŒṘ€j”:“:[])

-2 grazie a Erik the Outgolfer (usare pal posto di ;€poiché ”:è effettivamente la lunghezza 1; usare Ø[poiché è diventato una scorciatoia per ⁾[])

ŒṘ€p”:Ø[

Provalo online!

Un programma completo che stampa il risultato (come collegamento restituisce un elenco di elenchi di caratteri).

... ma c'è un modo per salvare usando STDIN?

Come?

ŒṘ€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 byte

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

Provalo online!

— Jörg Hülsermann
fonte

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

— user63956

@ user63956 non è necessario un ulteriore <?con quale opzione deve essere eseguita? Crea un tuo approccio, direi che ottenere voti positivi e titus nel frattempo hanno fatto qualcosa di simile

— Jörg Hülsermann,

Funziona con la -Rbandiera. I tag possono essere chiusi anche in costruzioni come eval()e create_function().

— user63956,

4

Perl 5 , 22 byte

19 byte di codice + -pflag.

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

O, per lo stesso ByteCount, s/./'$&':/g;s/$/[]/.

Abbastanza semplice: s/./'$&':/gcirconda ogni carattere tra virgolette e aggiunge un :dopo. $\viene stampato in modo implicito dopo ogni stampa, quindi impostarlo per []produrre il finale [].

Provalo online!

— Dada
fonte

4

Java (OpenJDK 8) ,86 83 76 byte

-3 byte grazie a @KevinCruijssen
-7 byte grazie a @FlorianSchaetz

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

Provalo online!

— Beluga vergognoso
fonte

È possibile rilasciare 4 byte. Il trailing ;non deve essere conteggiato per le risposte lambda, il ;dopo il }non è affatto necessario e il {e }può essere rimosso attorno al for-loop. E si potrebbe risparmiare più di 4 byte in Java 10 cambiando sia la Stringe charal var.

— Kevin Cruijssen l'

4

Brainfuck, 68 byte

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

Provalo online!

— daniero
fonte

Non funziona abbastanza con la stringa vuota - mi ha restituito due caratteri non validi nel tuo test online. Molto bello, altrimenti.

— NoseKnowsTutti il

@NoseKnowsAll Non riesco a replicarlo; Senza input non ottengo output. Potresti fornire un link aggiornato con quell'input?

— daniero,

Questo è quello che ho ottenuto quando lo eseguo :. Con un input vuoto, dovrebbe restituire "[]" senza virgolette.

— NoseKnowsTutti il

@NoseKnowsAll Il tuo link va all'ingresso "ciao mondo" (ottieni un link aggiornato premendo quel pulsante link / catena), ma sì, capisco cosa intendi. Ci penserò su

— daniero il

1

@NoseKnowsAll Ecco qua, l'ho risolto;)

— daniero il

3

Brain-Flak , 135 , 131 byte

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

Provalo online!

+1byte per la -cbandiera.

Grazie a WheatWizard per aver rimosso NOOP molto ovvi che non avevo per nessun motivo XD.

— DJMcMayhem
fonte

@WheatWizard> _> Sì, ti stavo solo mettendo alla prova ... Hahaha, grazie per averlo sottolineato. Proverò a giocare a golf più tardi, ma aggiungerò che ora lol

— DJMcMayhem

3

ML standard , 52 50 byte

Salvato 2 byte grazie a @Laikoni!

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

Provalo online!

String.translateè un nome purtroppo lunga, ma era 5 byte più breve di utilizzare concat, mape explode.

— musicman523
fonte

@Laikoni grazie! Dimentico sempre che gli operatori hanno una precedenza inferiore rispetto alle funzioni.

— musicman523,

3

Cubix , 31 29 byte

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

Apuò anche essere sostituito i; ~~cercando di capire se c'è un buon modo per spremere un altro byte o due da questo.~~ -2 byte grazie a MickyT! Superato anche da MickyT !

Si adatta a un cubo 3x3x3:

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

Guardalo online!

Provalo online!

— Giuseppe
fonte

È possibile salvare un paio di byte, usando un paio di incrementi per l'ultima parentesi. Ciò consente di comprimere un po 'la linea di fondouo@[)o'U);!A?ro;o;o;os:'/u:''

— MickyT

2

Python 2 , 47 byte

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

Provalo online!

— asta
fonte

Avevo lo stesso approccio, ma non ho capito la [1:-1]parte, quindi era più lunga dei totalmente umani. +1

— Mago del grano

Strano che la banale soluzione sia più lunga di soli 3 byte (in Python 3).

— Mr. Xcoder,

2

APL (Dyalog) , 21 19 byte

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

Provalo online!

'[]',⍨ le parentesi sono state aggiunte

'.' ogni personaggio

⎕R PCRE R eplaced con

'''&'':' una citazione, la corrispondenza, una citazione e due punti

— Adamo
fonte

2

sed , 19 18 byte

-1 byte grazie alla Giordania

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

Provalo online!

— Una
fonte

2

PHP, 39 byte

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

Esegui come pipe con -F.

— Titus
fonte

2

Convesso , 10 byte

{`':`}%"[]

Provalo online!

— GamrCorps
fonte

2

Cubix , 27 byte

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

Provalo online!

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

Guarda correre

Una variazione leggermente diversa dalla risposta di Guiseppe . Questo mette i due punti e la citazione in pila. Quindi scorre attraverso l'input, scambiando e producendo lo stack. Viene eliminato solo l'input e i due punti e la virgoletta vengono mantenuti.

Una volta raggiunta la fine dell'input, l'IP si meraviglia un po 'attorno al cubo, aggiungendo e producendo le parentesi. Ci sono un paio di comandi ridondanti nel mix.

— MickyT
fonte

Sintassi senza zucchero

Compito

Regole

Casi test

Haskell , 26 byte

Haskell, 33 28 26 byte

Python 3 , 32 byte

JavaScript ES6, 42 40 31 byte

Lisp comune, 50 42 byte

V , 11 byte

C, 55 54 53 byte

Python 3 , 41 38 36 byte

05AB1E , 15 12 11 10 byte

R, 51 byte

Pyth, 14 10 8 byte

spiegazione

Perl 6 , 19 byte

Retina, 12

Python 2 , 48 46 44 37 byte

Befunge , 29 27 byte

JavaScript (ES6), 36 byte

Provalo

Gelatina , 11 10 8 byte

Come?

PHP , 41 byte

Perl 5 , 22 byte

Java (OpenJDK 8) ,86 83 76 byte

Brainfuck, 68 byte

Brain-Flak , 135 , 131 byte

ML standard , 52 50 byte

Cubix , 31 29 byte

Python 2 , 47 byte

APL (Dyalog) , 21 19 byte

sed , 19 18 byte

PHP, 39 byte

Convesso , 10 byte

Cubix , 27 byte