!Insérer! ! n! b! e! t! w! e! e! n!

24

Publié à partir d' ici .

Ce défi est fortement "distillé" de cette question. Un merci spécial à @Akababa!

Dans cette tâche, vous devez insérer un point d'exclamation au début de la chaîne et après chaque caractère.

Règles

  • Il y aura toujours une entrée de chaîne non vide. L'entrée ne contiendra pas non plus d'onglets. Vous pouvez supposer que l'entrée ne contient que des caractères imprimables ASCII non étendus et des retours à la ligne.
  • L'entrée ne contiendra pas de retour à la ligne tant que votre langue ne pourra pas détecter un retour à la ligne.
  • Il s'agit d'un concours de code-golf ; la réponse la plus courte devrait l'emporter.

Exemples

  • 4 sauts de ligne entraînent 5 points d'exclamation délimités par des sauts de ligne. Il est très difficile de mettre cela en tant que texte Markdown, donc cela est indiqué à la place.
1 2 3 4 5 6
129591 129012 129127 129582

0

Les sorties

!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

Les sorties

! a! s! d! ! a! f! j! o! K! ! a! 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! a! o! j! ! ! ! f! a! j!

Un cas de test de base avec un seul caractère:

une

Les sorties

!une!

(Auto-complétion! Je plaisante, il n'y a rien de tel.) Contient des points d'exclamation:

!!
!!
!!
!!
!!

Les sorties:

!!!!!
!!!!!
!!!!!
!!!!!
!!!!!
code-golf  string 
— UNE
source
6
— Giuseppe
7
Je ne comprends vraiment pas le downvote - c'est un défi clair et bien écrit. Re: être un doublon - ce n'est pas le cas (précéder "!" Fait une grande différence), et je ne pense pas que quelqu'un l'ait suggéré (pas de votes serrés).
— Jonathan Allan
1
si une langue ne peut pas faire la différence entre a\net a, pouvons-nous exiger qu'il n'y ait pas de retour à la ligne?
— Giuseppe
13
Des votes descendants sont insérés entre chaque vote ascendant, tout comme ce que le récit décrit.
— Un
2
C'est mort.
— V. Courtois

Réponses:

12

Python 3 , 27 octets

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

Essayez-le en ligne!

Honnêtement, j'espère que quelqu'un pourra me montrer une façon cool de le faire avec un nombre d'octets plus petit.

— Réintégrer Monica
source
Cela ne gère pas correctement le cas de ligne vide
— s'écaille
@flakes Que voulez-vous dire? Si vous voulez dire une chaîne vide: nous n'avons pas besoin de gérer une chaîne vide (et indépendamment de ce qui sort !!dans ce cas, ce qui est logique pour moi). Si vous voulez dire la chaîne \n: c'est le cas, car la sortie correcte est !\n!.
— Jonathan Allan
3
@JAD Pour autant que je sache, il n'y a pas de chaîne vide dans les exemples. Non seulement cela, mais la première règle indique littéralement "il y aura toujours une entrée de chaîne non vide".
— Rétablir Monica
1
Ah, j'avais tort. Le premier exemple a une ligne vide au milieu de l'entrée. Mais cette réponse permettra de placer le point d'exclamation au milieu de cela !\n!\n!,. bon travail.
— flocons
1
codegolf.stackexchange.com/questions/190223/insert-nbetween/… comme vous le disiez pour montrer un chemin plus court
— U10-Forward - Rétablir Monica
8

JavaScript (ES6), 19 octets

Prend l'entrée comme un tableau de caractères.

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

Essayez-le en ligne!

JavaScript (ES6),  23  20 octets

Enregistré 3 octets grâce à @ShieruAsakoto

Prend l'entrée sous forme de chaîne.

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

Essayez-le en ligne!

JavaScript (ES6), 22 octets

Suggérée par @tjjfvi

Prend l'entrée sous forme de chaîne.

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

Essayez-le en ligne!

— Arnauld
source
3
— tjjfvi
@tjjfvi Nifty one!
— Arnauld
5
J'ai un 20 pour ton 23:s=>[,...s,,].join`!`
— Shieru Asakoto
7

R , 25 octets

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

Essayez-le en ligne!

Fonction acceptant et renvoyant un vecteur de caractères.

— Nick Kennedy
source
Peut raser 3 octets en basculant la forme de la fonction sur scan(,''), comme c'est le cas
— Sumner18
@ Sumner18 merci. J'ai commencé avec ça mais ça divise les entrées dans les espaces.
— Nick Kennedy
1
@ Sumner18 Le défi demande de gérer les entrées avec des nouvelles lignes, ce qui ne peut pas être fait avec scan(mais avec lequel la solution de Nick gère, au moins si vous affichez la sortie avec cat.)
— Robin Ryder
7

Code machine 8086, format .COM (MS-DOS 2+), 32 octets

(-1 selon l'émulateur: voir ci-dessous)

Pour de meilleurs résultats, redirigez l'entrée standard à partir d'un fichier, car la saisie donne une sortie étrange en raison de l'absence de mise en mémoire tampon; aussi, les sauts de ligne semblent un peu bizarres car ils sont stockés en tant que CR LF, etCR partie gâche la sortie.

Ce programme se comporte très bien dans une émulation MS-DOS réelle (par exemple PCjs) mais DOSBox semblait avoir des problèmes avec Ctrl + Z EOF (voir les commentaires dans la liste des assemblys), donc N'ESSAYEZ PAS d'entrer des données à l'aide de la console dans DOSBox à moins que vous ajoutez le chèque supplémentaire!

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

Quelques morceaux intéressants:

  • J'ai économisé de l'espace de données en réutilisant de la mémoire qui avait déjà été exécutée (l' 21Hin INT 21Hse trouve être !)

  • J'ai presque pu utiliser une astuce intéressante que j'ai trouvée sur la page "Le pouvoir caché des instructions BCD" qui m'aurait permis d'utiliser AAAau lieu d'un standard TESTpour comparerAL à 0, économisant un octet. Malheureusement, ce n'est pas entièrement documenté, donc je ne pouvais pas m'y fier: par exemple, PCjs n'ajuste rien d'autre que les drapeaux de portage et de portage auxiliaire. :-(

Code d'assemblage (mode idéal 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
source
6

Pepe , 47 octets

REREEeRErEErREeeEeeeeEREEeeREEeereeREEEEeeEReee

Essayez-le en ligne!

Explication:

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)
— indéfini
source
Comment écrivez-vous ce code? Y a-t-il un convertisseur de code que vous utilisez? Cela semble fou d'essayer d'écrire
— Cruncher
1
@Cruncher 1) J'utilise ce que mon guide. 2) Non, je n'utilise pas de convertisseur de code, j'utilise simplement le guide pour écrire le code.
— u_ndefined
6

Labyrinthe ,  19 11 10  9 octets

33
..
",@

Essayez-le en ligne!

Comment?

On entre dans le Labyrinthe en haut à gauche face à droite avec une pile infinie de zéros ...

                         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

Heureusement, nous n'avons pas besoin de gérer les non imprimables, sinon le premier zéro octet nous retournerait et ferait des ,ravages.

— Jonathan Allan
source
4

Perl 5 -p0, 17 6 octets

s,,!,g

Essayez-le en ligne!

Ma réponse initiale était -pet $_='!'.s,.,$&!,gr. Merci à @Nahuel Fouilleul pour avoir coupé 11 octets et à @Grimy pour la -p0pointe.

— Kjetil S.
source
2
— Nahuel Fouilleul
1
@NahuelFouilleul -lpdonne une sortie incorrecte pour le \n\n\n\ncas de test (retourne 4 sauts de ligne séparés !au lieu des 5 spécifiés). -p0fonctionne correctement.
— Grimmy
4

6502, 12 octets (13 octets si Apple II)

6502

Le code machine suppose qu'une paire d'emplacements de page zéro est connectée au matériel d'entrée de caractères ($ FE) et de sortie (FF). De nombreux systèmes basés sur 6502 facilitent les E / S de cette manière, bien que les adresses d'E / S ne soient généralement pas à zéro page.

Pour plus de simplicité, j'ai utilisé Py65 , un simulateur de système de micro-ordinateur 6502 écrit en Python.

Voici un vidage de mémoire de Py65. Vous pouvez charger le code suivant n'importe où dans la page zéro de sorte qu'il ne chevauche pas $ FE et $ 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

En cours d'exécution dans une fenêtre de commande Windows, vous pouvez coller (Ctrl + V) tout texte que vous désirez, ou vous pouvez simplement taper. Si vous tapez, appuyez sur Ctrl + J pour une nouvelle ligne (même caractère ASCII). Appuyez sur Ctrl + C pour interrompre le processeur et revenir à l'invite de commande Py65.

Naturellement, le code assembleur est plus facile à lire.

       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

Pour plus de clarté, voici le code assembleur au format 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

Le code ci-dessus suppose qu'un null indique qu'il n'y a pas d'entrée, donc continue l'interrogation jusqu'à ce qu'une valeur non nulle soit renvoyée.

À titre de comparaison, l'Apple I et l'Apple II signalent la disponibilité d'un nouveau caractère en définissant le bit 7 de l'adresse d'E / S du clavier, qui doit ensuite être effacé après la récupération du caractère. Sur ces systèmes, les E / S de caractères sont généralement effectuées en appelant des routines de surveillance du système au lieu d'accéder directement au matériel.

En appelant RDKEY ($ FD0C) et COUT ($ FDED), l'équivalent Apple II de ce qui précède peut être codé en 13 octets et peut être exécuté n'importe où dans la RAM. Voici le code que j'ai exécuté dans un émulateur Apple // e, aix sur Android 9.

Appuyez sur Retour a le même effet qu'une nouvelle ligne.

*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

Avez-vous remarqué qu'au lieu de la valeur ASCII normale # $ 21 pour le point d'exclamation, # $ A1 est utilisé à la place? En effet, l'envoi de valeurs ASCII standard à COUT provoque leur affichage en «mode inverse», noir sur blanc. L'affichage de l'ASCII en blanc normal sur noir nécessite d'ajouter # $ 80 à la valeur de caractère dans l'accumulateur avant d'appeler COUT. Parce que RDKEY renvoie des caractères avec le jeu de bits, les programmes d'assemblage ont généralement effacé le bit du caractère pour obtenir sa valeur ASCII avant de l'utiliser.

— Lee
source
1
Bienvenue sur le site! :)
— Rahul Bharadwaj
Merci, @Rahul!
— Lee
4

Bash , 36 octets

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

Essayez-le en ligne!

Cela compte sur la nouvelle ligne mettant fin à l'entrée pour la dernière! marque.

— frapper
source
Bienvenue! Veuillez envisager d'ajouter une explication ou un lien vers un interprète ou quelque chose, car les réponses uniquement codées sont automatiquement signalées comme de faible qualité.
— mbomb007
@ mbomb007, merci pour le pointeur.
— Spuck
1
Malheureusement, cela n'ajoute pas un !à la fin de l'entrée.
— Kritixi Lithos
@Cowsquack: sur mon terminal, la nouvelle ligne qui termine l'entrée obtient le! ajoutée. Sur tio.run, l'entrée doit être terminée par un retour chariot. J'ai mis à jour le lien vers Try it Online pour refléter cela.
— levée
4

MarioLANG , 95 94 90 89 69 octets

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

Essayez-le en ligne!

C'était la première fois que j'essayais MarioLANG, c'était très amusant!

Merci à Jo King pour -20 octets

Explication:

Ainsi, comme son nom l'indique, MarioLANG est conçu pour s'exécuter comme un jeu de Super Mario Bros. Il fonctionne de manière similaire à BF, avec une mémoire disposée dans une bande de cellules. Il existe des opérateurs pour incrémenter, décrémenter, imprimer (en ascii ou numérique) et lire dans la cellule de mémoire actuelle, et des opérateurs pour se déplacer vers la gauche ou la droite le long de la bande.

Mario (le pointeur d'instruction) commence toujours dans la cellule en haut à gauche du programme, avec sa direction de mouvement prévue vers la droite. Si Mario n'a pas d'objet semblable à un plancher sous lui (=, "ou #), il tombera jusqu'à ce qu'il atteigne un objet semblable à un plancher. Si Mario quitte l'espace du programme, le programme se termine en raison de Game Over :(

Ce programme spécifique peut essentiellement être divisé en deux moitiés: la configuration et la boucle.

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

Dans la section Configuration, nous incrémentons simplement la première cellule de mémoire jusqu'à ce que nous atteignions 33 - la valeur ASCII pour "!". Assez facile; si cela peut être joué au golf, c'est purement une question de forme. Mario commence en haut à gauche, ramasse 10 pièces, commence à tomber en ramassant le 11, change de direction, puis répète. Il ramasse les 11 dernières pièces sans changer de direction; il termine la section de configuration en bas à droite "+".

Dans la section de boucle, Mario commence par atteindre un ascenseur. Le "!" l'opérateur lui fait cesser le mouvement, de sorte qu'il reste dans l'ascenseur. En montant, il imprime le caractère ASCII correspondant à la valeur de la cellule mémoire actuelle (celle-ci est toujours 33, "!"), Puis passe à la cellule suivante en mémoire. Mario atteint le sommet et définit sa direction vers la droite. Il tombe et lit un caractère en entrée comme sa valeur ASCII (ou -1 si aucun caractère). Nous incrémentons parce que la seule mesure de contrôle dans MarioLANG est de sauter une instruction si la cellule de mémoire actuelle a une valeur de 0. Si c'est le cas, nous sautons de changer la direction de Mario, donc il ira directement du prochain étage à sa perte. Si ce n'est pas le cas, nous mettons la direction à gauche; marcher à gauche du sol en dessous diminue la cellule actuelle à sa valeur précédente,

Version précédente (89 octets):

+++++++++++>,
==========@"+
+++++++++++)[
@==========.==<
+++++++++++!(.-
===========#===
— Réintégrer Monica
source
62 octets en utilisant une boucle de multiplication au lieu d'un simple compteur
— Jo King
Bon maintenant c'est cool. Je mettrai à jour dès que j'aurai le temps de refaire l'explication, merci beaucoup!
— Rétablir Monica
1
Aha! 60 octets en multipliant 5 * 6 + 3 au lieu de 8 * 4 + 1
— Jo King
Mec, je sais que ce n'est pas exactement ton premier rodéo, mais c'est vraiment impressionnant. xD
— Rétablir Monica
En fait, c'est ma première fois à jouer au MarioLANG. J'ai juste une certaine expérience avec brainfuck ainsi qu'avec d'autres langages 2D
— Jo King
4

Perl 6 , 16 11 octets

{S:g/<(/!/}

Essayez-le en ligne!

Remplace toutes les correspondances de largeur nulle par des points d'exclamation. Les expressions rationnelles nulles ne sont pas autorisées, nous utilisons donc un marqueur de capture pour ne rien capturer à la place

— Jo King
source
3

05AB1E , 4 octets

€'!Ć

E / S sous forme de liste de caractères.

Essayez-le en ligne.

Explication:

€'!  '# 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
source
3

Triangulaire , 15 13 octets

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

Essayez-le en ligne!

-2 octets après avoir rappelé que Triangular a un opérateur d'arrêt conditionnel.

Je pense que c'est aussi court que possible sur celui-ci. triangulaire fait des opérateurs de changement de direction conditionnels, mais ils fonctionnent malheureusement différemment des autres conditionnels. Alors que tous les autres vérifient si ToS <= 0, les conditions de changement de direction vérifient ToS! = 0. Si ce n'était pas le cas, nous aurions 10 octets sous la forme de Bq3~#*/@<<.

Non golfé:

    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

Version précédente (15 octets):

B.3\.*#).(/?~@<
— Réintégrer Monica
source
3

SimpleTemplate , 23 octets

C'est une langue que j'ai écrite, et c'était censé être pour les modèles, mais bon.

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

Devrait être presque explicite, une fois que vous voyez le code non golfé:

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

Et une explication:

  • !- Imprime le !caractère littéral
  • {@each argv.0 as char}- Boucle à travers chaque caractère, avec la valeur définie sur la variable char( facultatif , la variable par défaut est _).
    argv.0est le premier paramètre passé à la render()méthode du compilateur.
  • {@echo char}!- sort la charvariable et un !caractère littéral .
    Pour la version golfée, la variable par défaut _est utilisée à la place.
  • {@/}- ferme la boucle ( facultatif )

Solution Pure SimpleTemplate :

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

Crée une fonction x qui produit le même résultat.

Vous pouvez l'utiliser comme ceci:

{@call x "this is an example"}

Vous pouvez essayer tout cela sur: http://sandbox.onlinephpfunctions.com/code/f6baff8d411fc8227ece81eccf05b6e7d3586bfa

Sur la ligne 908, vous pouvez utiliser les variables $golfed, $ungolfedet $fntester toutes les versions.

Cependant, s'il est autorisé à utiliser un tableau de caractères, le code est simplifié (20 octets):

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

Et non golfé:

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

Fondamentalement, génère tous les éléments du tableau, joints par "!", entourés de littéraux !.
En raison des limitations de la classe du compilateur, l'espace est obligatoire (dans la version golfée).

Ce code est également extrêmement difficile à utiliser dans SimpleTemplate pur (en utilisant la fonction comme exemple):

{@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}

Le @callpeut appeler une fonction qui existe en PHP, ce qui signifie que ce n'est pas une pure solution SimpleTemplate .

— Ismael Miguel
source
2

Gema , 11 personnages

\A=\!
?=?\!

Malheureusement !commence un commentaire dans Gema, doit donc être échappé.

Exemple d'exécution:

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!

Essayez-le en ligne!

— homme au travail
source
2

Gelée , 5 octets

Ż”!ṁż

Un programme complet acceptant une chaîne, qui imprime le résultat.

Essayez-le en ligne!

Comment?

Ż”!ṁż - 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
source
2

Japt , 4 octets

rP'!

Essayez-le

r      Replace
 P     all empty strings "" with
  '!   An exclamation mark (If '!' wasn't a special character in Japt I could remove the quote)
— Incarnation de l'ignorance
source
You'd only be able to ditch the ' if the replacement were a number.
— Shaggy
2

Japt, 4 bytes

rP'!

Try it

Japt -P, 7 bytes

Unfortunately ! is a reserved character, necessitating the quotation marks.

ï'! i'!

Try it

Not much to explain: ï is Cartesian product and i prepends.

— Shaggy
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.