!Inserire! ! N! B! E! T! W! E! E! N!

24

Postato da qui .

Questa sfida è altamente "distillata" da questa domanda. Un ringraziamento speciale a @Akababa!

In questa attività, è necessario inserire un punto esclamativo all'inizio della stringa e dopo ogni carattere.

Regole

  • Ci sarà sempre un input senza stringa vuota. Anche l'input non conterrà schede. Si può presumere che l'input contenga solo caratteri e nuove righe stampabili ASCII non estese.
  • L'input non conterrà newline finali purché la tua lingua non sia in grado di rilevare una nuova riga.
  • Questa è una gara di code-golf ; la risposta più breve dovrebbe vincere.

Esempi

  • 4 newline producono 5 punti esclamativi delimitati da newline. È molto difficile metterlo come un testo Markdown, quindi questo è indicato invece.
1 2 3 4 5 6
129591 129012 129127 129582

0

Uscite

! 1! ! 2! ! 3! ! 4! ! 5! ! 6!
! 1! 2! 9! 5! 9! 1! ! 1! 2! 9! 0! 1! 2! ! 1! 2! 9! 1! 2! 7! ! 1! 2! 9! 5! 8! 2!
!
! 0!

asd afjoK ak: e
kPrLd
    fOJOE;
    KFO
KFkepjgop sgpaoj faj

Uscite

! Una! S! D! ! Una! F! J! O! K! !! Un k:!! E!
! K! P! R! L! D!
! ! ! ! ! F O J O E!!!!!;!
! ! ! ! ! K! F! O!
! K! F! K! E! P! J! G! O! P! ! S! G! P! Una! O! J! ! ! ! F! Una! J!

Un caso di test di base con un solo carattere:

un'

Uscite

!un!

(Completamento automatico! Sto scherzando, non esiste nulla del genere.) Contiene punti esclamativi:

!!
!!
!!
!!
!!

Uscite:

!!!!!
!!!!!
!!!!!
!!!!!
!!!!!
code-golf  string 
— UN
fonte
6
— Giuseppe,
7
Davvero non capisco il downvote - questa è una sfida chiara e ben scritta. Ri: essere un duplicato - non lo è (precedendo '!' Fa una grande differenza), e non credo che nessuno l'abbia suggerito (nessun voto ravvicinato).
— Jonathan Allan,
1
se una lingua non è in grado di distinguere tra a\ne a, possiamo richiedere che non ci siano nuove righe finali?
— Giuseppe,
13
I downgrade vengono inseriti tra tutti i voti, proprio come descrive la sfida.
— A̲̲
2
Questo è morto
— V. Courtois,

Risposte:

12

Python 3 , 27 byte

lambda s:f"!{'!'.join(s)}!"

Provalo online!

Onestamente, spero che qualcuno possa mostrarmi un modo interessante per farlo con un numero di byte inferiore.

— Ripristina Monica
fonte
Questo non gestisce correttamente il caso della linea vuota
— scaglie
@flakes Che vuoi dire? Se intendi una stringa vuota: non abbiamo bisogno di gestire una stringa vuota (e indipendentemente da questo output !!in quel caso, che è ciò che ha senso per me). Se intendi la stringa \n: sì, poiché l'output corretto è !\n!.
— Jonathan Allan,
3
@JAD Per quanto posso vedere, non ha una stringa vuota negli esempi. Non solo, ma la prima regola afferma letteralmente "ci sarà sempre un input di stringa non vuoto".
— Ripristina Monica il
1
Ah, ho sbagliato. Il primo esempio ha una riga vuota nel mezzo dell'input. Ma questa risposta gestirà ponendo il punto esclamativo in mezzo a quel, !\n!\n!. bel lavoro.
— fiocchi
1
codegolf.stackexchange.com/questions/190223/insert-nbetween/… come stavi dicendo per mostrare un modo più breve
— U10-Forward - Reinstate Monica il
8

JavaScript (ES6), 19 byte

Accetta input come una matrice di caratteri.

s=>`!${s.join`!`}!`

Provalo online!

JavaScript (ES6),  23  20 byte

3 byte salvati grazie a @ShieruAsakoto

Accetta l'input come stringa.

s=>[,...s,,].join`!`

Provalo online!

JavaScript (ES6), 22 byte

Suggerito da @tjjfvi

Accetta l'input come stringa.

s=>s.replace(/|/g,"!")

Provalo online!

— Arnauld
fonte
3
— tjjfvi il
@tjjfvi Nifty one!
— Arnauld,
5
Ho un 20 per il tuo 23:s=>[,...s,,].join`!`
— Shieru Asakoto il
7

R , 25 byte

function(x)gsub("","!",x)

Provalo online!

Una funzione che accetta e restituisce un vettore di caratteri.

— Nick Kennedy
fonte
Può radere 3 byte cambiando il modulo della funzione in scan(,''), come tio.run/##K/r/P724NElDSUlHSVFJpzg5MU9DR11dU/O/…
— Sumner18
@ Sumner18 grazie. Ho iniziato con questo, ma divide l'input negli spazi.
— Nick Kennedy,
1
@ Sumner18 La sfida chiede di gestire l'input con newline, che non si può fare con scan(ma che la soluzione di Nick gestisce, almeno se si visualizza l'output con cat.)
— Robin Ryder
7

8086 codice macchina, formato .COM (MS-DOS 2+), 32 byte

(-1 a seconda dell'emulatore: vedi sotto)

Per i migliori risultati reindirizzare l'input standard da un file, poiché la digitazione produce un output dall'aspetto strano a causa della mancanza di buffering; inoltre, le newline sembrano un po 'strane perché sono memorizzate come CR LFeCR parte rovina l'output.

Questo programma si comporta bene in una vera emulazione MS-DOS (es. PCjs) ma DOSBox sembra avere problemi con Ctrl + Z EOF (vedi commenti nella lista dell'assembly), quindi NON provare a inserire input usando la console in DOSBox a meno che tu non aggiungi il controllo extra!

BB 01 00 53 59 BA 0B 01 B4 40 CD 21 4A 4B B4 3F CD 21 85 C0 74 09 B4 40 43 41 CD 21 49 EB EE C3

Alcuni bit interessanti:

  • Ho salvato qualche spazio dati riutilizzando memoria che era già stato eseguito (la 21Hin INT 21Hsembra essere !)

  • Sono stato quasi in grado di utilizzare un trucco interessante che ho trovato nella pagina "Il potere nascosto delle istruzioni BCD" che mi avrebbe permesso di utilizzare al AAAposto di uno standard TESTper confrontare ALa 0, salvando un byte. Sfortunatamente, questo non è completamente documentato, quindi non potevo fare affidamento su di esso: ad esempio, PCjs non regola nient'altro che i flag carry e carry ausiliari. :-(

Codice assembly (modalità ideale TASM):

IDEAL
MODEL   TINY

CODESEG
ORG 100H

;; DOSBox (tested with 0.74-2) didn't seem to handle Ctrl-Z as EOF
;; so uncomment the ";;" lines to run it there.
MAIN:
    MOV     BX,1
    PUSH    BX
    POP     CX
    MOV     DX,OFFSET MAIN_1+1  ; The 21H in INT 21H
    MOV     AH,40H
MAIN_1:
    INT     21H
    DEC     DX
    ;;PUSH  DX
    ;;POP   SI
IO_LOOP:
    DEC     BX
    MOV     AH,3FH
    INT     21H
    ;;; This should work on an non-emulated PC. 
    ;;;AAA      ; AL=0?
    TEST    AX,AX
    JZ      DONE
    ;;CMP   [BYTE PTR SI],1AH
    ;;JZ    DONE
    MOV     AH,40H
    INC     BX
    INC     CX
    INT     21H
    DEC     CX
    JMP     IO_LOOP
DONE:
    RET
ENDS
END MAIN
— ErikF
fonte
6

Pepe , 47 byte

REREEeRErEErREeeEeeeeEREEeeREEeereeREEEEeeEReee

Provalo online!

Spiegazione:

REREEeRE # Push 0,then input (str),then 0 -> (R)
         # The zeroes are pushed to correct the inserting
rEE # Begin loop labelled 0 -> (r)
  rREeeEeeeeE # Push "!" -> (R)
              # r flag inserts it instead of pushing
  REEeeREEee # Move pointer pos 2 steps forward -> (R)
ree # Loop while (R) != 0
REEEEeeE # Remove characters of (R) that are in stack of (r)
         # Removes the 0 in (R)
Reee # Output (R)
— non definito
fonte
Come scrivi questo codice? C'è qualche convertitore di codice che usi? Sembra folle provare a scrivere
— Cruncher
1
@Cruncher 1) Io uso questo come la mia guida. 2) No, non uso un convertitore di codice, utilizzo semplicemente la guida per scrivere il codice.
— U_ndefined
6

Labyrinth ,  19 11 10  9 byte

33
..
",@

Provalo online!

Come?

Entriamo nel Labirinto in alto a sinistra, rivolto a destra con una pila infinita di zeri ...

                         I / O    stack
                                  0,0,0,...
3 - pop * 10 + 3                  3,0,0,0,...
  - 2 neighbours, forward
3 - pop * 10 + 3                  33,0,0,0,...
  - 2 neighbours, forward
. - pop & print chr          !    0,0,0,...
  - T junction from the side
  -   TOS==0, forward
, - read chr or -1       L        76,0,0,0,...   or   -1,0,0,0
  - T junction from the base
  -   if TOS > 0 right:
" -     no-op                     76,0,0,0,...
  -     2 neighbours, forward
. -     pop & print chr      L    0,0,0,...
  -     T junction from the side
  -       TOS==0, forward
3 -       ...back to the start
  -   elif TOS == -1 left:
@ -     exit                                          we're out!


  * right, but on the first occasion (from above) we hit the wall and turn
    around, so that's like a left

Fortunatamente non abbiamo bisogno di gestire i non stampabili, altrimenti il ​​primo byte zero ci farebbe girare e farebbe ,casino.

— Jonathan Allan
fonte
4

Zsh , 32 byte

for c ('' ${(s::)1})echo -nE $c!

Provalo online!

(s::)si divide in caratteri, ''aggiunge un elemento vuoto all'inizio, quindi echo -nE $c!riecheggia ciascuno seguito da un !.

— GammaFunction
fonte
4

Perl 5 -p0, 17 6 byte

s,,!,g

Provalo online!

La mia risposta originale era -pe $_='!'.s,.,$&!,gr. Grazie a @Nahuel Fouilleul per il taglio di 11 byte e @Grimy per l'informazione -p0.

— Kjetil S.
fonte
2
— Nahuel Fouilleul,
1
@NahuelFouilleul -lpfornisce un output errato per il \n\n\n\ncaso di test (restituisce 4 separati da nuova riga !invece del 5 specificato). -p0funziona correttamente.
— Grimmy,
4

6502, 12 byte (13 byte se Apple II)

6502

Il codice macchina presuppone che una coppia di posizioni di pagina zero siano collegate all'hardware di input caratteri ($ FE) e output (FF). Molti sistemi basati su 6502 facilitano l'I / O in questo modo, anche se gli indirizzi I / O di solito non sono nella pagina zero.

Per semplicità, ho usato Py65 , un simulatore di sistema per microcomputer 6502 scritto in Python.

Ecco un dump della memoria da Py65. È possibile caricare il codice seguente in qualsiasi punto della pagina zero in modo che non si sovrapponga a $ FE e $ FF.

       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.mem 0:b
0000:  a9  21  85  ff  a5  fe  f0  fc  85  ff  d0  f4

In esecuzione in una finestra di comando di Windows, puoi incollare (Ctrl + V) tutto il testo che desideri, oppure puoi semplicemente digitare. Se si digita, premere Ctrl + J per una nuova riga (stesso carattere ASCII). Premi Ctrl + C per interrompere il processore e tornare al prompt dei comandi di Py65.

Naturalmente, il codice assembly è più facile da leggere.

       PC  AC XR YR SP NV-BDIZC
6502: 0000 00 00 00 ff 00110010
.d 00:0b
$0000  a9 21     LDA #$21
$0002  85 ff     STA $ff
$0004  a5 fe     LDA $fe
$0006  f0 fc     BEQ $0004
$0008  85 ff     STA $ff
$000a  d0 f4     BNE $0000

Per chiarezza, ecco il codice assembly in formato CBA65 .

; ASSEMBLE:
; cba65 bangit
;
; LOAD/RUN
; python3 py65/monitor.py -i 00fe -o 00ff -l bangit.bin
; goto 0000

        .FILES  BIN=256

; I/O LOCATIONS
GETC    .EQU    $FE             ; (1) MOVING PY65'S GETC TO ZP SHAVES 1 BYTE
PUTC    .EQU    $FF             ; (1) MOVING PY65'S PUTC TO ZP SHAVES 2 BYTES

        .ORG    $0000

VROOM   LDA     #'!'
        STA     PUTC
VROOM2  LDA     GETC
        BEQ     VROOM2
        STA     PUTC
        BNE     VROOM

        .END

Apple II

Il codice sopra presuppone che un valore nullo indichi l'assenza di input, quindi continua il polling fino a quando non viene restituito un valore non nullo.

Per fare un confronto, Apple I e Apple II segnalano la disponibilità di un nuovo carattere impostando il bit 7 dell'indirizzo I / O della tastiera, che quindi deve essere cancellato dopo aver recuperato il carattere. Su tali sistemi, l'I / O dei caratteri viene in genere eseguito chiamando le routine di monitoraggio del sistema anziché accedere direttamente all'hardware.

Chiamando RDKEY ($ FD0C) e COUT ($ FDED), l'equivalente Apple II di quanto sopra può essere codificato in 13 byte ed è eseguibile ovunque nella RAM. Ecco il codice che ho eseguito in un emulatore di Apple // e, a2ix su Android 9.

La pressione di Return ha lo stesso effetto di una nuova riga.

*300L

0300-   A9 A1       LDA   #$A1
0302-   20 ED FD    JSR   $FDED
0305-   20 0C FD    JSR   $FD0C
0308-   20 ED FD    JSR   $FDED
030B-   F0 F3       BEQ   $0300

Hai notato che al posto del normale valore ASCII # $ 21 per il punto esclamativo, viene utilizzato # $ A1? Questo perché l'invio di valori ASCII standard a COUT li fa visualizzare in "modalità inversa", nero su bianco. La visualizzazione di ASCII in bianco normale su nero richiede l'aggiunta di # $ 80 al valore del carattere nell'accumulatore prima di chiamare COUT. Poiché RDKEY restituisce caratteri con il set hi-bit, i programmi di assemblaggio generalmente hanno cancellato il bit del carattere per ottenere il suo valore ASCII prima di usarlo.

— sottovento
fonte
1
Benvenuti nel sito! :)
— Rahul Bharadwaj il
Grazie @Rahul!
— sottovento il
4

Bash , 36 byte

while read -n1 c;do printf \!$c;done

Provalo online!

Questo conta sulla nuova riga che termina l'input per l'ultimo! marchio.

— Spuck
fonte
Benvenuto! Ti consigliamo di aggiungere una spiegazione o un link a un interprete o qualcosa del genere, poiché le risposte di solo codice vengono automaticamente contrassegnate come di bassa qualità.
— mbomb007,
@ mbomb007, grazie per il puntatore.
— spuntato il
1
Sfortunatamente questo non aggiunge un !alla fine dell'input.
— Kritixi Lithos,
@Cowsquack: sul mio terminale, la newline che termina l'input ottiene il! aggiunto. Su tio.run, l'input deve essere terminato con un ritorno a capo. Ho aggiornato il collegamento a Provalo online per riflettere ciò.
— spuntato il
4

MarioLANG , 95 94 90 89 69 byte

++++++
======< >)
>+++++++",+[
=======<.==<
>+++++++!(.-
========#===

Provalo online!

La prima volta che ho provato MarioLANG, è stato molto divertente!

Grazie a Jo King per -20 byte

Spiegazione:

Quindi, come suggerisce il nome, MarioLANG è progettato per essere eseguito come un gioco di Super Mario Bros. Funziona in modo simile a BF, con la memoria disposta in un nastro di celle. Ci sono operatori per incrementare, decrementare, stampare (come ascii o numerici) e leggere nella cella di memoria corrente e operatori per spostarsi a sinistra o a destra lungo il nastro.

Mario (il puntatore alle istruzioni) inizia sempre nella cella in alto a sinistra del programma, con la direzione di movimento prevista impostata a destra. Se Mario non ha un oggetto simile a un pavimento sotto di lui (=, "o #), cadrà fino a raggiungere un oggetto simile a un piano. Se Mario lascia lo spazio del programma, il programma termina a causa di Game Over :(

Questo programma specifico può essere sostanzialmente diviso in due parti: il setup e il loop.

   Setup                          Loop
-----------------------------------------------
                       |
++++++                 |          
======<                |          >)
>+++++++               |          ",+[
=======<               |          .==<
>+++++++               |          !(.-
========               |          #===

Nella sezione Setup, stiamo semplicemente incrementando la prima cella di memoria fino a raggiungere 33 - il valore ASCII per "!". Abbastanza facile; se questo può essere giocato a golf, è puramente una questione di forma. Mario parte da sinistra in alto, raccoglie 10 monete, inizia a cadere quando prende l'undicesimo, cambia direzione, quindi si ripete. Raccoglie le ultime 11 monete senza cambiare direzione; termina la sezione di installazione in basso a destra "+".

Nella sezione ad anello, Mario inizia raggiungendo un ascensore. Il "!" l'operatore gli fa cessare il movimento, in modo che rimanga sull'ascensore. Durante la salita, stampa il carattere ASCII corrispondente sul valore della cella di memoria corrente (questo è sempre 33, "!"), Quindi passa alla cella successiva in memoria. Mario raggiunge la cima e imposta la sua direzione a destra. Cade e legge un carattere dall'input come valore ASCII (o -1 se nessun carattere). Aumentiamo perché l'unica misura di controllo in MarioLANG è saltare un'istruzione se la cella di memoria corrente ha un valore di 0. Se lo fa, salteremo cambiando la direzione di Mario, quindi camminerà dal piano successivo fino al suo destino. In caso contrario, impostiamo la direzione a sinistra; camminando a sinistra fuori dal piano sottostante decrementa la cella corrente al suo valore precedente,

Versione precedente (89 byte):

+++++++++++>,
==========@"+
+++++++++++)[
@==========.==<
+++++++++++!(.-
===========#===
— Ripristina Monica
fonte
62 byte utilizzando un ciclo di moltiplicazione anziché solo un contatore
— Jo King,
Okay adesso È FANTASTICO. Aggiornerò non appena avrò tempo di ripetere la spiegazione, grazie mille!
— Ripristina Monica il
1
Aha! 60 byte moltiplicando 5 * 6 + 3 invece di 8 * 4 + 1
— Jo King il
Amico, so che non è esattamente il tuo primo rodeo, ma è davvero impressionante. xD
— Ripristina Monica il
In realtà, questa è la prima volta che gioco a golf con MarioLANG. Ho solo esperienza con Brainfuck e altri linguaggi 2D
— Jo King,
4

Perl 6 , 16 11 byte

{S:g/<(/!/}

Provalo online!

Sostituisce tutte le corrispondenze di larghezza zero con punti esclamativi. Le regex nulle non sono consentite, quindi utilizziamo un marcatore di acquisizione per catturare invece nulla

— Jo King
fonte
3

05AB1E , 4 byte

€'!Ć

I / O come elenco di caratteri.

Provalo online.

Spiegazione:

€'!  '# Prepend a "!"-item before each character in the (implicit) input-list
   Ć  # Enclose (append the first character of the list at the end of it)
      # (after which the result is output implicitly)
— Kevin Cruijssen
fonte
3

Triangolare , 15 13 byte

B\3;#*~.,</@<

Provalo online!

-2 byte dopo aver ricordato che Triangular ha un operatore di arresto condizionale.

Credo che sia breve quanto questo. Triangolare ha avere operatori direzione del cambiamento condizionali, ma purtroppo funzionare in modo diverso rispetto agli altri condizionali. Mentre tutti gli altri controllano se ToS <= 0, i condizionali che cambiano direzione controllano ToS! = 0. Se così non fosse, avremmo 10 byte sotto forma diBq3~#*/@<< .

Ungolfed:

    B
   \ 3
  ; # *
 ~ . , <
/ @ <
----------------------------------------------------
B3*              - Push 11 and 3, then pop both and push their product.
    <,<          - Change directions 3 times (to save 2 bytes on last line)
        @/       - Print Top of Stack value as a character, do not pop
          ~;\    - Push a character from input to ToS. Halt if ToS <= 0. Change Direction.
              #  - Print ToS as a character and pop

Versione precedente (15 byte):

B.3\.*#).(/?~@<
— Ripristina Monica
fonte
3

SimpleTemplate , 23 byte

Questa è una lingua che ho scritto, e doveva essere per i modelli, ma bene.

!{@eachargv.0}{@echo_}!

Dovrebbe essere quasi autoesplicativo, una volta che vedi il codice ungolfed:

!{@each argv.0 as char} {@echo char}!{@/}

E una spiegazione:

  • ! - Stampa il letterale ! carattere
  • {@each argv.0 as char}- Passa attraverso ogni carattere, con il valore impostato sulla variabile char( opzionale , la variabile predefinita è _).
    argv.0è il primo parametro passato arender() metodo del compilatore.
  • {@echo char}!- genera la charvariabile e un !carattere letterale .
    Per la versione golfata, la variabile predefinita_ viene invece utilizzata la .
  • {@/}- chiude il loop ( opzionale )

Soluzione Pure SimpleTemplate :

{@fn x}!{@eachargv.0}{@echo_}!{@/}{@/}

Crea una funzione x che genera lo stesso risultato.

Puoi usarlo in questo modo:

{@call x "this is an example"}

Puoi provare tutto questo su: http://sandbox.onlinephpfunctions.com/code/f6baff8d411fc8227ece81eccf05b6e7d3586bfa

Sulla linea 908, è possibile utilizzare le variabili $golfed, $ungolfede $fnper testare tutte le versioni.

Tuttavia, se è consentito utilizzare una matrice di caratteri, il codice è semplificato (20 byte):

!{@echoj"!" argv.0}!

E non golfato:

!{@echo separator "!" argv.0}!

Fondamentalmente, genera tutti gli elementi dell'array, uniti da "!", circondati da letterali !.
A causa delle limitazioni nella classe del compilatore, lo spazio è obbligatorio (nella versione golfizzata).

Questo codice è anche estremamente difficile da usare in SimpleTemplate puro (usando la funzione come esempio):

{@fn x}!{@echoj"!" argv.0}!{@/}

{@// alternative: @call str_split into a "a char array"}
{@set a "a", " ", "c", "h", "a", "r", " ", "a", "r", "r", "a", "y"}

{@call x a}

La @callpuò chiamare una funzione che esiste in PHP, il che significa che non è una pura SimpleTemplate soluzione.

— Ismael Miguel
fonte
2

Gema , 11 personaggi

\A=\!
?=?\!

Sfortunatamente ! inizia un commento in Gema, quindi deve essere evitato.

Esecuzione di esempio:

bash-5.0$ echo -ne '1 2 3 4 5 6\n129591 129012 129127 129582\n\n0' | gema '\A=\!;?=?\!'
!1! !2! !3! !4! !5! !6!
!1!2!9!5!9!1! !1!2!9!0!1!2! !1!2!9!1!2!7! !1!2!9!5!8!2!
!
!0!

Provalo online!

— uomo al lavoro
fonte
2

Gelatina , 5 byte

Ż”!ṁż

Un programma completo che accetta una stringa, che stampa il risultato.

Provalo online!

Come?

Ż”!ṁż - Main Link: list of characters, s   e.g. "abc"
 ”!   - character '!'                           '!'
   ṁ  - mould like:
Ż     -   s with a zero prepended              "!!!!"
    ż - zip together with s                    ["!a","!b","!c",'!']
      - implicit (smashing) print              !a!b!c!
— Jonathan Allan
fonte
2

Japt , 4 byte

rP'!

Provalo

r      Replace
 P     all empty strings "" with
  '!   An exclamation mark (If '!' wasn't a special character in Japt I could remove the quote)
— Incarnazione dell'ignoranza
fonte
Saresti in grado di abbandonare il 'se la sostituzione fosse un numero.
— Shaggy,
2

Japt , 4 byte

rP'!

Provalo

Japt -P , 7 byte

Purtroppo !è un carattere riservato, che richiede le virgolette.

ï'! i'!

Provalo

Non c'è molto da spiegare: ïè il prodotto cartesiano e iantepone.

— ispido
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.