!I!n!s!e!r!t! !i!n!b!e!t!w!e!e!n!

Question

Posted from here.

This challenge is highly "distilled" from this question. Special thanks to @Akababa!

In this task, you should insert an exclamation mark at the start of the string and after every character.

Rules

There will always be a non-empty-string input. The input will not contain tabs either. You can assume that the input only contain non-extended ASCII printable characters and newlines.
The input will not contain trailing newlines as long as your language can't detect a newline.
This is a code-golf contest; the shortest answer should win.

Examples

4 newlines result in 5 newline-delimited exclamation marks. It is very hard to put this as a Markdown text, so this is stated instead.

1 2 3 4 5 6
129591 129012 129127 129582

0

Outputs

!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

Outputs

!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!

A base test case with only one character:

Outputs

!a!

(Auto-completion! Just kidding, there is no such thing.) Contains exclamation marks:

!!
!!
!!
!!
!!

Outputs:

!!!!!
!!!!!
!!!!!
!!!!!
!!!!!

I really don't understand the downvote - this is a clear and well written challenge. Re: being a duplicate - it's not (preceding '!' makes for a big difference), and I don't believe anyone has suggested so (no close votes). — Jonathan Allan, Commented Aug 18, 2019 at 13:45
if a language can't tell the difference between a\n and a, can we require that there are no trailing newlines? — Giuseppe, Commented Aug 18, 2019 at 14:29
Downvotes are inserted between every upvote, just like what the challege describes. — user85052, Commented Aug 18, 2019 at 14:34
Is the case of a single space input " ", is the output supposed to be "!" or "! !" — Kai, Commented Aug 19, 2019 at 3:52

dhilln · Accepted Answer · 2019-12-25 03:07:35Z

2

Javascript (27 bytes)

My first code golf, 27 bytes in Javascript. Could probably shave some more bytes off, but I'm not too sure.

f={x:s=>`!${s.join('!')}!`}

Example Usage

console.log(f.x('1 2 3 4 5'.split('')))
// Output: !1! !2! !3! !4! !5!

answered Dec 25, 2019 at 3:07

dhilln

291 bronze badge

1

\$\begingroup\$ Welcome to CCGC! Using the way of defining lambdas that has been kind of standardized on this site, this is 21 bytes: Try it online! (unless the lambda is called recursively, the f= does not need to be counted) \$\endgroup\$
– Stephen
Commented Dec 25, 2019 at 3:58

Add a comment |

TwilightSparkle · Accepted Answer · 2020-08-12 06:20:57Z

2

1+, 20 19 bytes

1##11"+""*"**+;,;1#

1+ 19 vs 18 MAWP

Error-terminating because comparison is expensive.

edited Aug 12, 2020 at 6:20

answered Aug 12, 2020 at 5:59

TwilightSparkle

3,9461 gold badge17 silver badges33 bronze badges

\$\begingroup\$ I think i'm winning for now ;) btw, mawp submissions should be here github.com/8Dion8/8Dion8.github.io/blob/master/scraper/… \$\endgroup\$
– Dion
Commented Aug 12, 2020 at 8:20
\$\begingroup\$ @Dion Yeah, only 1 byte away! I'm creating the 1+ answer list now. \$\endgroup\$
– TwilightSparkle
Commented Aug 12, 2020 at 8:32
\$\begingroup\$ I created a python script to gather everything... Maybe you could change it a bit and use it for gathering 1+ answers? If you are interested, ill clean up the code so its understandable xd \$\endgroup\$
– Dion
Commented Aug 12, 2020 at 8:51
\$\begingroup\$ @Dion Apparently your script searches for 1+ with the SE search tool but that will not work well for 1+. Manual 1+ answer list \$\endgroup\$
– TwilightSparkle
Commented Aug 12, 2020 at 10:58
\$\begingroup\$ github.com/8Dion8/8Dion8.github.io/blob/master/scraper/… is the current script \$\endgroup\$
– Dion
Commented Aug 12, 2020 at 11:12

| Show 3 more comments

pxeger · Accepted Answer · 2021-02-14 15:58:42Z

2

Zsh, 12 bytes

<<<${1///!}!

Try it online!

answered Feb 14, 2021 at 15:58

pxeger

24.6k4 gold badges53 silver badges141 bronze badges

Add a comment |

ngn · Accepted Answer · 2022-10-03 17:01:47Z

2

K (ngn/k), 13 12 bytes

-1 byte from @ngn's savings

{x,/y,'x}"!"

Try it online!

Creates a function projection, with x fixed to "!".

y,'x pair-wise append an exclamation mark to each character in the input
x,/ flatten the list, using "!" as the seed (to prepend the leading "!")

edited Oct 3, 2022 at 17:01

ngn

15.3k2 gold badges43 silver badges87 bronze badges

answered Feb 12, 2021 at 16:20

coltim

6,0937 silver badges13 bronze badges

1

\$\begingroup\$ save a byte by turning "!" into a curried argument: f:{x,/y,'x}"!" \$\endgroup\$
– ngn
Commented Feb 12, 2021 at 19:05

Add a comment |

att · Accepted Answer · 2022-10-03 21:46:14Z

2

C (gcc), 48 45 39 bytes

f(char*s){printf("!%.1s",s++)>1&&f(s);}

Try it online!

-3 thanks to ceilingcat

edited Oct 3, 2022 at 21:46

answered Aug 19, 2019 at 23:34

att

21.7k2 gold badges16 silver badges62 bronze badges

Add a comment |

The Empty String Photographer · Accepted Answer · 2023-05-30 13:36:14Z

2

Python, 30 Bytes

lambda x:'!%s!'%'!'.join([*x])

It feels like these methods were designed for the challenge!

-1 from Jacob (now noodle man) by using the cursed `%` (Dun dun dun!)

-3 from Glorfindel for using a starred method for conversion!

!T!r!y! !r!u!n!n!i!n!g! !i!t! !o!n!l!i!n!e!

edited May 30, 2023 at 13:36

answered May 29, 2023 at 9:00

The Empty String Photographer

2,2981 gold badge9 silver badges25 bronze badges

\$\begingroup\$ Here's 33, I don't know much python so it can likely be golfed further \$\endgroup\$
– noodle person
Commented May 29, 2023 at 14:07
\$\begingroup\$ list(...) can always be [*...] instead \$\endgroup\$
– Jo King ♦
Commented May 30, 2023 at 13:24
1

\$\begingroup\$ 27 bytes - you don't even need to convert it to a list, since any iterable will work. \$\endgroup\$
– The Thonnu
Commented May 30, 2023 at 14:53

Add a comment |

Shaggy · Accepted Answer · 2023-05-30 16:50:39Z

2

Rockstar, 67 bytes

listen to S
while S
cut S
join S with "!"
say "!"+S+"!"
listen to S

Try it here (Code will need to be pasted in)

edited May 30, 2023 at 16:50

answered May 30, 2023 at 16:02

Shaggy

43.5k4 gold badges36 silver badges94 bronze badges

Add a comment |

Dadsdy · Accepted Answer · 2023-05-31 05:47:41Z

2

Python 3, 29 Bytes

print('',*input(),'',sep="!")

Try It Online

answered May 31, 2023 at 5:47

Dadsdy

2,0956 silver badges24 bronze badges

Add a comment |

Neil · Accepted Answer · 2019-08-18 11:11:29Z

1

Charcoal, 6 bytes

⭆Ｓ⁺!ι!

Try it online! Link is to verbose version of code. Works on empty strings too. Input format is somewhat cumbersome due to Charcoal's lack of EOF. Works by preceding each character with a ! and then suffixing a final ! on the end. Alternative version, also 6 bytes:

⪫!!⪫Ｓ!

Try it online! Link is to verbose version of code. Works by joining the characters on ! and then wrapping them in !!.

answered Aug 18, 2019 at 11:11

Neil

177k12 gold badges74 silver badges281 bronze badges

Add a comment |

Giuseppe · Accepted Answer · 2019-08-18 14:38:13Z

1

SNOBOL4 (CSNOBOL4), 94 bytes

I	I =INPUT	:F(END)
S	I LEN(1) . X REM . I	:F(O)
	O ='!' O X	:(S)
O	OUTPUT =O '!'
	O =	:(I)
END

Try it online!

Prints with an additional trailing newline (as SNOBOL always prints a line break). The way input is consumed, there is no way of distinguishing between a final line ending in \n or not.

answered Aug 18, 2019 at 14:38

Giuseppe

28.8k3 gold badges31 silver badges105 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

Stax, 6 5 bytes

_z'!R

Run and debug it

Replace "" with "!" using regex replacement. I don't exactly understand why this works.

Edit: Found it in the Ecma spec: 15.5.4.10

If there is a match with an emptystring (in other words, if the value of regexp.lastIndex is left unchanged), increment regexp.lastIndex by 1.

Old Stuff:

I ~~would~~ have been able to get to 5 bytes ~~in either of two scenarios.~~

If input was provided in an escaped literal e.g. "line1\nline2". But I opted against that for the sake of "usability".
If there was not a ~~bug~~ feature in stax's zip implementation when encountering empty strings/arrays.

Kai · Accepted Answer · 2019-08-20 19:50:04Z

1

Wolfram Language (Mathematica), 49 48 42 bytes

#~StringSplit~""~StringRiffle~{a="!",a,a}&

Try it online!

-6 bytes thanks to @attinat

edited Aug 20, 2019 at 19:50

answered Aug 19, 2019 at 4:42

Kai

2111 silver badge4 bronze badges

\$\begingroup\$ The code in the Header, Code, and Footer sections is run. You can use infix notation and drop the { } in StringSplit for 42 bytes \$\endgroup\$
– att
Commented Aug 19, 2019 at 23:24
\$\begingroup\$ @attinat Thanks that helps a lot! \$\endgroup\$
– Kai
Commented Aug 20, 2019 at 19:50

Add a comment |

snail_ · Accepted Answer · 2019-08-24 05:38:20Z

1

Ahead, 12 bytes

~irj!'~
@Wu<

Try it online!

answered Aug 24, 2019 at 5:38

snail_

2,67012 silver badges16 bronze badges

Add a comment |

lqdev · Accepted Answer · 2019-08-26 20:18:28Z

1

Lua, 31 bytes

print((io.read():gsub("","!")))

answered Aug 26, 2019 at 20:18

lqdev

1112 bronze badges

Add a comment |

jdt · Accepted Answer · 2019-09-13 06:40:36Z

1

C (gcc), 32 bytes

f(s){printf("!%s",s)-1&&f(s+4);}

Try it online!

edited Sep 13, 2019 at 6:40

answered Aug 22, 2019 at 12:16

jdt

4,5251 gold badge14 silver badges18 bronze badges

Add a comment |

Galen Ivanov · Accepted Answer · 2019-09-13 07:52:14Z

1

Red, 47 bytes

func[s][parse s[insert"!"any[skip insert"!"]]s]

Try it online!

answered Sep 13, 2019 at 7:52

Galen Ivanov

21.2k3 gold badges24 silver badges61 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

1

C#, 142 bytes

public class P{public static void Main(string[]a){System.Console.Write("!");foreach(char c in a[0]){System.Console.Write(c.ToString()+"!");}}}

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Aug 19, 2019 at 18:25

canttalkjustcode

1914 bronze badges

Add a comment |

Razetime · Accepted Answer · 2021-02-12 13:09:32Z

1

Pip, 5 bytes

aJW'!

Try it online!

The JW builtin was made for challenges like this.

answered Feb 12, 2021 at 13:09

Razetime

27.4k3 gold badges29 silver badges72 bronze badges

Add a comment |

hyperneutrino · Accepted Answer · 2021-04-18 04:12:39Z

1

Branch, 11 bytes

33.,[.33.,]

Try it on the online Branch interpreter!

Put 33 on the tree and output (!). Then, grab input. Finally, while that value is not EOF, output it, output 33 (!), and grab input again.

answered Apr 18, 2021 at 4:12

hyperneutrino♦

42.6k5 gold badges68 silver badges224 bronze badges

Add a comment |

Aaroneous Miller · Accepted Answer · 2021-04-19 14:19:18Z

1

Vim, 13 bytes

:%s/\_./!&/g

Works by putting a ! before every character, including newline characters. The TIO version doesn't work properly for the 4 newline testcase, but it does work in Vim.

Try it online!

answered Apr 19, 2021 at 14:19

Aaroneous Miller

9,6901 gold badge24 silver badges39 bronze badges

Add a comment |

SjoerdPennings · Accepted Answer · 2021-05-12 11:23:33Z

1

BRASCA, 14 13 bytes

-1 byte thanks to RezNesX

,![$'!oo{]'!o

Try it online!

Explanation

,               - Reverse stack
 ![$    {]      - Loop stack length:
    '!oo        -     Print "!" followed by the next letter
          '!o   - Print the last "!"

edited May 12, 2021 at 11:23

answered May 11, 2021 at 12:20

SjoerdPennings

2,46016 silver badges30 bronze badges

1

\$\begingroup\$ 13 bytes: ,![$'!oo{]'!o \$\endgroup\$
– RezNesX
Commented May 12, 2021 at 11:20

Add a comment |

Axuary · Accepted Answer · 2021-05-19 19:06:57Z

1

Subleq (8-bit), 1211 bytes

-1 byte for removing last 0

Subleq emulator

Explanation

0:  2 -1 33 ' Output 2: (char(33)); 3rd argument is not used for output so use it for memory
3: -1  8 -1 ' Read input to 8:, exit if null
6:  8 -1  0 ' Output 8:
9:  8  8    ' 8: = 0 goto 0

edited May 19, 2021 at 19:06

answered May 11, 2021 at 12:08

Axuary

3,4766 silver badges11 bronze badges

Add a comment |

bigyihsuan · Accepted Answer · 2022-10-03 20:12:47Z

1

Go, 105 bytes

import."regexp"
func f(s[]byte)[]byte{return append(MustCompile(`(?s).`).ReplaceAll(s,[]byte(`!$0`)),33)}

Attempt This Online!

answered Oct 3, 2022 at 20:12

bigyihsuan

10.8k1 gold badge23 silver badges66 bronze badges

Add a comment |

Engineer Toast · Accepted Answer · 2022-10-03 20:22:31Z

Excel, 44 bytes

="!"&CONCAT(MID(A1,SEQUENCE(LEN(A1)),1)&"!")

"!" is just the first !.
CONCAT(MID(A1,SEQUENCE(LEN(A1)),1)&"!")
- SEQUENCE(LEN(A1)) creates an array 1, 2, ... X where X is the length of the input.
- MID(A1,SEQUENCE(~),1) pulls the n^th character from the input.
- MID(~)&"!" adds ! after every one of those characters.
- CONCAT(MID(~)&"!") combines all those n^th character + ! into one string.

^{Note: The line breaks are there with or without Word Wrap turned on but it won't look right until you turn it on. The screenshot has Word Wrap turned on.}

chunes · Accepted Answer · 2022-10-03 23:06:32Z

1

Factor, ³¹ 28 bytes

[ 33 interleaved [I !${}!I]]

Attempt This Online!

33 interleaved Insert an exclamation point between each character of the input.
[I !${}!I] Interpolate the above string into the ${}, adding exclamation points to the beginning and end, and print.

edited Oct 3, 2022 at 23:06

answered Oct 3, 2022 at 22:50

chunes

26.8k3 gold badges24 silver badges53 bronze badges

Add a comment |

DLosc · Accepted Answer · 2022-10-24 22:16:40Z

BQN, 11 bytes

'!'⊸(⊣∾´∾¨)

Anonymous tacit function that takes and returns a string. Try it at BQN online!

Explanation

'!'⊸(⊣∾´∾¨)
    (      )  Call the following function with the original argument on the right
'!'⊸          and '!' on the left:
         ∾¨     Concatenate each (prepends '!' to each character, resulting
                in a list of two-character strings)
       ∾´       Right-fold that list on concatenation
     ⊣          with a starting value of the left argument (i.e. '!')

A port of Sʨɠɠan's APL solution is also 11 bytes:

(∾⊢∾∾¨)⟜'!'

Try it!

EasyasPi · Accepted Answer · 2022-10-26 20:25:09Z

ARM Thumb machine code, 12 bytes

21 22 08 c8 0c c1 00 2b fb d1 70 47

Assembly source:

    .syntax unified
    .arch armv7-a
    .thumb
    .thumb_func
    .globl insert_between
// input: r0: pointer to null terminated UTF-32LE string
//        r1: pointer to buffer
// output: null terminated UTF-32LE string at *r1
// C callable prototype:
//   void insert_between(const char32_t *in, char32_t *out);
insert_between:
    // Put '!' in a register for later
    movs   r2, #'!'
.Lloop:
    // Load char from pointer, advance pointer
    ldmia  r0!, {r3}                          @ tmp = *in++;
    // Store '!' then the char from the pointer.
    // The null terminator will be included,
    // which also adds the trailing '!'.
    stmia  r1!, {r2, r3}                      @ *out++ = '!', *out++ = tmp;
    // Loop if r3 wasn't a null terminator
    cmp    r3, #0
    bne    .Lloop
    // return
    bx     lr

Callable from C with the following prototype:

void insert_between(const char32_t *in, char32_t *out);

As with most of my Thumb string solutions, everything is null terminated UTF-32 thanks to ldmia and stmia being the only narrow instructions to load and advance a pointer.

Zoey · Accepted Answer · 2023-06-09 11:34:50Z

1

C, 42 bytes

f(char *s){printf("!%c",*s);if(*s++)f(s);}

Essentially to not have to have two printf statments I have the printf run on the null byte of the string which prints the '!' but the null byte is ignored.

Easier to read

f(char *s){
  // Prints ! and char of string
  printf("!%c", *s);
 
  // If more string than recurse for next char
  if(*s != 0) f(s+1);
}

edited Jun 9, 2023 at 11:34

answered Jun 9, 2023 at 3:29

Zoey

1114 bronze badges

\$\begingroup\$ I don't know much C, would removing that space be valid? \$\endgroup\$
– rydwolf
Commented Jun 9, 2023 at 5:27

Add a comment |

Dadsdy · Accepted Answer · 2023-06-17 02:41:37Z

1

(,) 111 91 Chars or \$91\log_{256}(3)\approx18.03\$ Bytes

((),()()()()()()()())((),(())(())(())(())())(,,,(()()),(,(()(),((()()())),,(())))(()()),())

TIO

edited Jun 17, 2023 at 2:41

answered May 31, 2023 at 5:29

Dadsdy

2,0956 silver badges24 bronze badges

Add a comment |

Vincent · Accepted Answer · 2024-08-14 11:59:51Z

Marbles, 774 bytes

An elegant 25 x 31 grid of 774 characters:

○══════════════════════╗
║○═══════════════════╗ ║
║║○════════════════╗ ║ ║
║║║○═════════════╗ ║ ║ ║
║║║║○══════════╗ ║ ║ ║ ║
║║║║║○═══════╗ ║ ║ ║ ║ ║
║║║║║║○════╗ ║ ║ ║ ║ ║ ║
║║║║║║║○═╗ ║ ║ ║ ║ ║ ║ ║
║║║║║║║║○╜○╜○╜○╜○╜○╜○╜○╜
║║║║║║║║ ┃ ║ ║ ║ ║ ┃ ║ ║
║║║║║║║║◆╢◆╢◆╢◆╢◆╢◆╢◆╢◆╢
║║║║║║║║ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃
║║║║║║║║◇╢◇╢◇╢◇╢◇╢◇╢◇╢◇╢
║║║║║║║║○╬═╬═╬═╬═╬═╬═╬╗║
║║║║║║║║║║╔╬╗║╔╬╗║╔╬╗║║║
║║║║║║║║╓╢╙╢╓╢╙╢╓╢╙╢╓╢╙╢
║║║║║║║║╚╬╝║╚╬╝║╚╬╝║╚╬╝║
║║║║║║║║○╜○╜○╜○╜○╜○╜○╜○╜
║║║║║║║║ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃
║║║║║║║║◇╜◇╜◇╜◇╜◇╜◇╜◇╜◇╜
║║║║║║║║◆╢◆╢◆╢◆╢◆╢◆╢◆╢◆╢
║║║║║║║║ ┃ ┃ ┃ ┃ ┃ ┃ ┃ ┃
║║║║║║║║◇╢◇╢◇╢◇╢◇╢◇╢◇╢◇╢
║║║║║║║╚═╝ ║ ║ ║ ║ ║ ║ ║
║║║║║║╚════╝ ║ ║ ║ ║ ║ ║
║║║║║╚═══════╝ ║ ║ ║ ║ ║
║║║║╚══════════╝ ║ ║ ║ ║
║║║╚═════════════╝ ║ ║ ║
║║╚════════════════╝ ║ ║
║╚═══════════════════╝ ║
╚══════════════════════╝

Marbles is not available on tio.run yet but the test examples can be run using marbles.py:

± echo test | ./marbles.py exclamation.txt --quiet --no-display
!t!e!s!t!
!

Ungolfed version:

╔══════════════════════════════════════════════════╗
║  ╔════════════════════════════════════════════╗  ║
║  ║  ╔══════════════════════════════════════╗  ║  ║
║  ║  ║  ╔════════════════════════════════╗  ║  ║  ║
║  ║  ║  ║  ╔══════════════════════════╗  ║  ║  ║  ║
║  ║  ║  ║  ║  ╔════════════════════╗  ║  ║  ║  ║  ║
║  ║  ║  ║  ║  ║  ╔══════════════╗  ║  ║  ║  ║  ║  ║    ┓ 8 marbles representing a byte
║  ║  ║  ║  ║  ║  ║  ╔════════○  ○  ○  ○  ○  ○  ○  ○    ┛ This is the main variable
║  ║  ║  ║  ║  ║  ║  ║        ╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗  ┓
║  ║  ║  ║  ║  ║  ║  ║        ╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝  ┃
║  ║  ║  ║  ║  ║  ║  ║     ○══╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╗ ┃ Synchronization
║  ║  ║  ║  ║  ║  ║  ║     ║  ╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗║ ┃ Right-most marble exits first
║  ║  ║  ║  ║  ║  ║  ║     ║  ╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝║ ┃
║  ║  ║  ║  ║  ║  ║  ║     ╚══╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╝ ┛
║  ║  ║  ║  ║  ║  ║  ║        ╙○ ╙○ ╙○ ╙○ ╙○ ╙○ ╙○ ╙○   ┓ Set value to 0x21
║  ║  ║  ║  ║  ║  ║  ║        ║  ║  ┃  ║  ║  ║  ║  ┃    ┛ (the ascii character '!')
║  ║  ║  ║  ║  ║  ║  ║        ╟◆ ╟◆ ╟◆ ╟◆ ╟◆ ╟◆ ╟◆ ╟◆   ┓
║  ║  ║  ║  ║  ║  ║  ║        ┃  ┃  ┃  ┃  ┃  ┃  ┃  ┃    ┃ Write the byte to stdout
║  ║  ║  ║  ║  ║  ║  ║        ╟◇ ╟◇ ╟◇ ╟◇ ╟◇ ╟◇ ╟◇ ╟◇   ┃ LSB is on the right
║  ║  ║  ║  ║  ║  ║  ║        ┃  ┃  ┃  ┃  ┃  ┃  ┃  ┃    ┛
║  ║  ║  ║  ║  ║  ║  ║        ╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗  ┓
║  ║  ║  ║  ║  ║  ║  ║        ╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝  ┃
║  ║  ║  ║  ║  ║  ║  ║     ○══╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╗ ┃ Synchronization
║  ║  ║  ║  ║  ║  ║  ║     ║  ╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗╚═╗║ ┃ Right-most marble exits first
║  ║  ║  ║  ║  ║  ║  ║     ║  ╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝╔╤╝║ ┃
║  ║  ║  ║  ║  ║  ║  ║     ╚══╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╬╛═╝ ┛
║  ║  ║  ║  ║  ║  ║  ║        ╙○ ╙○ ╙○ ╙○ ╙○ ╙○ ╙○ ╙○   ┓ Read a byte from stdin
║  ║  ║  ║  ║  ║  ║  ║        ┃  ┃  ┃  ┃  ┃  ┃  ┃  ┃    ┃ LSB is on the right
║  ║  ║  ║  ║  ║  ║  ║        ╙◇ ╙◇ ╙◇ ╙◇ ╙◇ ╙◇ ╙◇ ╙◇   ┛
║  ║  ║  ║  ║  ║  ║  ║        ╟◆ ╟◆ ╟◆ ╟◆ ╟◆ ╟◆ ╟◆ ╟◆   ┓
║  ║  ║  ║  ║  ║  ║  ║        ┃  ┃  ┃  ┃  ┃  ┃  ┃  ┃    ┃ Write the byte to stdout
║  ║  ║  ║  ║  ║  ║  ║        ╟◇ ╟◇ ╟◇ ╟◇ ╟◇ ╟◇ ╟◇ ╟◇   ┃ LSB is on the right
║  ║  ║  ║  ║  ║  ║  ║        ┃  ┃  ┃  ┃  ┃  ┃  ┃  ┃    ┛
║  ║  ║  ║  ║  ║  ║  ╚════════╝  ║  ║  ║  ║  ║  ║  ║
║  ║  ║  ║  ║  ║  ╚══════════════╝  ║  ║  ║  ║  ║  ║
║  ║  ║  ║  ║  ╚════════════════════╝  ║  ║  ║  ║  ║
║  ║  ║  ║  ╚══════════════════════════╝  ║  ║  ║  ║
║  ║  ║  ╚════════════════════════════════╝  ║  ║  ║
║  ║  ╚══════════════════════════════════════╝  ║  ║
║  ╚════════════════════════════════════════════╝  ║
╚══════════════════════════════════════════════════╝

This is the first marbles submission ever :)

Rules

Examples

97 Answers 97

Javascript (27 bytes)

1+, 20 19 bytes

Zsh, 12 bytes

K (ngn/k), 13 12 bytes

C (gcc), 48 45 39 bytes

Python, 30 Bytes

-1 from Jacob (now noodle man) by using the cursed % (Dun dun dun!)

-3 from Glorfindel for using a starred method for conversion!

Rockstar, 67 bytes

Python 3, 29 Bytes

Charcoal, 6 bytes

SNOBOL4 (CSNOBOL4), 94 bytes

Stax, 6 5 bytes

Wolfram Language (Mathematica), 49 48 42 bytes

Ahead, 12 bytes

Lua, 31 bytes

C (gcc), 32 bytes

Red, 47 bytes

C#, 142 bytes

Pip, 5 bytes

Branch, 11 bytes

Vim, 13 bytes

BRASCA, 14 13 bytes

Explanation

Subleq (8-bit), 1211 bytes

Explanation

Go, 105 bytes

Excel, 44 bytes

Factor, 31 28 bytes

BQN, 11 bytes

Explanation

ARM Thumb machine code, 12 bytes

C, 42 bytes

(,) 111 91 Chars or \$91\log_{256}(3)\approx18.03\$ Bytes

Marbles, 774 bytes

Your Answer

Sign up or log in

Post as a guest

Linked

Related

-1 from Jacob (now noodle man) by using the cursed `%` (Dun dun dun!)

Factor, ³¹ 28 bytes