# What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on the first try can be difficult. There is a much better chance of your challenge being well received if you post it in the Sandbox first.

See the Sandbox FAQ for more information on how to use the Sandbox.

## Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

• How are tags added to questions? – guest271314 Jan 9 '19 at 7:51
• @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] – James Aug 29 '19 at 15:19
• Why no featured anymore? Can't we have it auto-added or something? – S.S. Anne Sep 26 '19 at 15:57
• @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary – caird coinheringaahing Sep 29 '19 at 13:43

## Tower of Hanoi Hamiltonian Cycle

Every tower of Hanoi has a unique Hamiltonian cycle of length 3ⁿ. The cycle for n=1 is simply 1| | , |1| , | |1 while for n=2 it is as follows:

12          move disc 1 from rod 1 to rod 2
2   1                 2          1        3
1   2             1          2        3
12            1          3        1
1       2             2          3        2
1   2                 1          1        2
12                1          2        3
2   1             2          2        1
2       1             1          3        1 - closes cycle


Your task is to write a program or function which, given a positive integer n, returns the Hamiltonian cycle for the Hanoi Graph of order n.

You can output the graph starting at any point and traversing it in either order. You can output the graph as a list of positions or a list of moves. It must be possible to loop back from the last line of your output to the first, but you don't have to repeat the position.

This is , so the shortest solution wins.

• The cycle can be constructed as a trivial variant of solving the standard tower of Hanoi puzzle, making this a duplicate. – Peter Taylor Sep 3 '16 at 8:25
• The standard solution is simply a straight line along the edge of the Hanoi graph, while the cycle is a fractal. How is that a trivial variant? – Neil Sep 3 '16 at 10:04

# Warn me when charger is unplugged!

So, I've a Compaq Presario V6000 laptop. Two years ago, battery died because of overcharging; So I had to plug charger in order to work with. Without the charger plugged, it runs out of power after ~4 seconds. Unfortunately, today I found out that charger port is tighten because of intense use & charger gets unplugged after few minutes. Your task is to solve my problem by writing a full program which warns me about unplugged charger!

# GOAL

• Write a full program that opens an X windows or makes similar graphical drawing that warns me about unplugged charger with writing "WARNING" in a readable font with size 36 and in color red.

• Your program must warn me in less than 2 seconds after being unplugged.

• Information about my laptop is available HERE. It's running Slacko puppy 6.3.0 with JWM & other default programs.

Here's what I've in /dev directory :

adsp
agpgart
audio
audio1
autofs
bsg
btrfs-control
bus
cdrom
char
console
cpu_dma_latency
cuse
dac960_gam
dri
dsp
dsp1
dvd
fb0
fd
full
fuse
hidraw0
hpet
hwrng
input
kmsg
log
loop0
loop1
loop10
loop11
loop12
loop13
loop14
loop15
loop2
loop3
loop4
loop5
loop6
loop7
loop8
loop9
loop-control
mapper
mcelog
md0
mem
mixer
mixer1
mouse
mptctl
nbd0
nbd1
nbd10
nbd11
nbd12
nbd13
nbd14
nbd15
nbd2
nbd3
nbd4
nbd5
nbd6
nbd7
nbd8
nbd9
net
network_latency
network_throughput
null
port
ppp
psaux
ptmx
pts
ptya0
ptya1
ptya2
ptya3
ptya4
ptya5
ptya6
ptya7
ptya8
ptya9
ptyaa
ptyab
ptyac
ptyae
ptyaf
ptyb0
ptyb1
ptyb2
ptyb3
ptyb4
ptyb5
ptyb6
ptyb7
ptyb8
ptyb9
ptyba
ptybb
ptybc
ptybd
ptybe
ptybf
ptyc0
ptyc1
ptyc2
ptyc3
ptyc4
ptyc5
ptyc6
ptyc7
ptyc8
ptyc9
ptyca
ptycb
ptycc
ptycd
ptyce
ptycf
ptyd0
ptyd1
ptyd2
ptyd3
ptyd4
ptyd5
ptyd6
ptyd7
ptyd8
ptyd9
ptyda
ptydb
ptydc
ptydd
ptyde
ptydf
ptye0
ptye1
ptye2
ptye3
ptye4
ptye5
ptye6
ptye7
ptye8
ptye9
ptyea
ptyeb
ptyec
ptyed
ptyee
ptyef
ptyp0
ptyp1
ptyp2
ptyp3
ptyp4
ptyp5
ptyp6
ptyp7
ptyp8
ptyp9
ptypa
ptypb
ptypc
ptypd
ptype
ptypf
ptyq0
ptyq1
ptyq2
ptyq3
ptyq4
ptyq5
ptyq6
ptyq7
ptyq8
ptyq9
ptyqa
ptyqb
ptyqc
ptyqd
ptyqe
ptyqf
ptyr0
ptyr1
ptyr2
ptyr3
ptyr4
ptyr5
ptyr6
ptyr7
ptyr8
ptyr9
ptyra
ptyrb
ptyrc
ptyrd
ptyre
ptyrf
ptys0
ptys1
ptys2
ptys3
ptys4
ptys5
ptys6
ptys7
ptys8
ptys9
ptysa
ptysb
ptysc
ptysd
ptyse
ptysf
ptyt0
ptyt1
ptyt2
ptyt3
ptyt4
ptyt5
ptyt6
ptyt7
ptyt8
ptyt9
ptyta
ptytb
ptytc
ptytd
ptyte
ptytf
ptyu0
ptyu1
ptyu2
ptyu3
ptyu4
ptyu5
ptyu6
ptyu7
ptyu8
ptyu9
ptyua
ptyub
ptyuc
ptyud
ptyue
ptyuf
ptyv0
ptyv1
ptyv2
ptyv3
ptyv4
ptyv5
ptyv6
ptyv7
ptyv8
ptyv9
ptyva
ptyvb
ptyvc
ptyvd
ptyve
ptyvf
ptyw0
ptyw1
ptyw2
ptyw3
ptyw4
ptyw5
ptyw6
ptyw7
ptyw8
ptyw9
ptywa
ptywb
ptywc
ptywd
ptywe
ptywf
ptyx0
ptyx1
ptyx2
ptyx3
ptyx4
ptyx5
ptyx6
ptyx7
ptyx8
ptyx9
ptyxa
ptyxb
ptyxc
ptyxd
ptyxe
ptyxf
ptyy0
ptyy1
ptyy2
ptyy3
ptyy4
ptyy5
ptyy6
ptyy7
ptyy8
ptyy9
ptyya
ptyyb
ptyyc
ptyyd
ptyye
ptyyf
ptyz0
ptyz1
ptyz2
ptyz3
ptyz4
ptyz5
ptyz6
ptyz7
ptyz8
ptyz9
ptyza
ptyzb
ptyzc
ptyzd
ptyze
ptyzf
ram0
ram1
ram10
ram11
ram12
ram13
ram14
ram15
ram2
ram3
ram4
ram5
ram6
ram7
ram8
ram9
random
rfkill
rtc0
sda
sda1
sda2
sequencer
sequencer2
shm
snd
sr0
stderr
stdin
stdout
tty
tty0
tty1
tty10
tty11
tty12
tty13
tty14
tty15
tty16
tty17
tty18
tty19
tty2
tty20
tty21
tty22
tty23
tty24
tty25
tty26
tty27
tty28
tty29
tty3
tty30
tty31
tty32
tty33
tty34
tty35
tty36
tty37
tty38
tty39
tty4
tty40
tty41
tty42
tty43
tty44
tty45
tty46
tty47
tty48
tty49
tty5
tty50
tty51
tty52
tty53
tty54
tty55
tty56
tty57
tty58
tty59
tty6
tty60
tty61
tty62
tty63
tty7
tty8
tty9
ttya0
ttya1
ttya2
ttya3
ttya4
ttya5
ttya6
ttya7
ttya8
ttya9
ttyaa
ttyab
ttyac
ttyae
ttyaf
ttyb0
ttyb1
ttyb2
ttyb3
ttyb4
ttyb5
ttyb6
ttyb7
ttyb8
ttyb9
ttyba
ttybb
ttybc
ttybd
ttybe
ttybf
ttyc0
ttyc1
ttyc2
ttyc3
ttyc4
ttyc5
ttyc6
ttyc7
ttyc8
ttyc9
ttyca
ttycb
ttycc
ttycd
ttyce
ttycf
ttyd0
ttyd1
ttyd2
ttyd3
ttyd4
ttyd5
ttyd6
ttyd7
ttyd8
ttyd9
ttyda
ttydb
ttydc
ttydd
ttyde
ttydf
ttye0
ttye1
ttye2
ttye3
ttye4
ttye5
ttye6
ttye7
ttye8
ttye9
ttyea
ttyeb
ttyec
ttyed
ttyee
ttyef
ttyp0
ttyp1
ttyp2
ttyp3
ttyp4
ttyp5
ttyp6
ttyp7
ttyp8
ttyp9
ttypa
ttypb
ttypc
ttypd
ttype
ttypf
ttyq0
ttyq1
ttyq2
ttyq3
ttyq4
ttyq5
ttyq6
ttyq7
ttyq8
ttyq9
ttyqa
ttyqb
ttyqc
ttyqd
ttyqe
ttyqf
ttyr0
ttyr1
ttyr2
ttyr3
ttyr4
ttyr5
ttyr6
ttyr7
ttyr8
ttyr9
ttyra
ttyrb
ttyrc
ttyrd
ttyre
ttyrf
ttys0
ttyS0
ttys1
ttyS1
ttys2
ttyS2
ttys3
ttyS3
ttys4
ttys5
ttys6
ttys7
ttys8
ttys9
ttysa
ttysb
ttysc
ttysd
ttyse
ttysf
ttyt0
ttyt1
ttyt2
ttyt3
ttyt4
ttyt5
ttyt6
ttyt7
ttyt8
ttyt9
ttyta
ttytb
ttytc
ttytd
ttyte
ttytf
ttyu0
ttyu1
ttyu2
ttyu3
ttyu4
ttyu5
ttyu6
ttyu7
ttyu8
ttyu9
ttyua
ttyub
ttyuc
ttyud
ttyue
ttyuf
ttyv0
ttyv1
ttyv2
ttyv3
ttyv4
ttyv5
ttyv6
ttyv7
ttyv8
ttyv9
ttyva
ttyvb
ttyvc
ttyvd
ttyve
ttyvf
ttyw0
ttyw1
ttyw2
ttyw3
ttyw4
ttyw5
ttyw6
ttyw7
ttyw8
ttyw9
ttywa
ttywb
ttywc
ttywd
ttywe
ttywf
ttyx0
ttyx1
ttyx2
ttyx3
ttyx4
ttyx5
ttyx6
ttyx7
ttyx8
ttyx9
ttyxa
ttyxb
ttyxc
ttyxd
ttyxe
ttyxf
ttyy0
ttyy1
ttyy2
ttyy3
ttyy4
ttyy5
ttyy6
ttyy7
ttyy8
ttyy9
ttyya
ttyyb
ttyyc
ttyyd
ttyye
ttyyf
ttyz0
ttyz1
ttyz2
ttyz3
ttyz4
ttyz5
ttyz6
ttyz7
ttyz8
ttyz9
ttyza
ttyzb
ttyzc
ttyzd
ttyze
ttyzf
uhid
uinput
urandom
vcs
vcs1
vcs2
vcs3
vcs4
vcs5
vcsa
vcsa1
vcsa2
vcsa3
vcsa4
vcsa5
vga_arbiter
vhost-net
zero


Here's what I've in /etc directory

acpi                      hostname               pavrecord
asound.state              hosts.allow            pkcs11
at-spi2                   hosts.deny             ppp
bash_completion.d         init.d                 precord
belocs                    inittab                printcap
ca-certificates           inputrc                profile
ca-certificates.conf      issue                  profile.d
ca-certificates.conf.new  jwm-2.3.xslt           protocols
cdburnerdevice            kde                    Puppybackgroundpicture
codepage                  keymap_previous        ramdiskfssize
cron.daily                lazarus                ramdisksize
cups                      ld.so.cache            rc.d
dbus-1                    ld.so.conf             rc_keymaps
default                   ld.so.conf.d           rc_maps.cfg
dhcpcd.conf               localtime              request-key.conf
dhcpcd.conf.new           localtime-copied-from  request-key.d
dhcpcd.duid               logrotate.d            resolutionfix
dhcpcd_state_notify       lvm                    resolv.conf
dhcpcd_state_notify.bak   lynx.cfg               rpc
dict.conf                 lynx.lss               samba
dictd.conf                mailcap                sane.d
DISTRO_SPECS              mc                     securetelnetrc
drirc                     mime.types             services
eventmanager              mke2fs.conf.new        shells
fb.modes                  modprobe.d             simple_network_setup
fdprm                     modules                slsh.rc
file                      modules.conf           ssl
floppy                    mousebuttons           sudo.conf
fltk                      mousedevice            sudoers
fontmap                   mtab                   sudoers.d
fonts                     my.cnf                 system.jwmrc
foomatic                  my.cnf.d               udev
fpc.cfg                   mysqlaccess.conf       uniconf.conf
fppkg                     nanorc                 usb_modeswitch.conf
fppkg.cfg                 nanorc.new             usb_modeswitch.d
frisbee                   NETWORKING             vga
fstab                     networkmodules         wcpufreqdriver
fstab.bak                 networks               wgetrc
gamin                     network-wizard         windowmanager
gconf                     nscd.conf              wpa_supplicant.conf
gftp                      nscd.conf.new          wpa_supplicant.conf.new
group                     nsswitch.conf          wvdial.conf
group-                    oldmousedevice         wvdial_options
gtk-2.0                   pam.d                  xextraoptions
gtk-3.0                   pango                  xorgoverrides
hiawatha                  passwd
host.conf                 passwd-

• Your program must not hurt my friend in any way

This is a . Shortest codes win!

• This is an interesting one. However, the obvious problem is the fact that is it must be always running as a process, so an interpreted programming language will have problems, am I right? – Andreï Kostyrka Sep 3 '16 at 1:14
• To other users: I think that the amount of information dumped into the the code areas could be greatly reduced by omitting such irrelevant things as sudoers, for example. Another think is making this challenge “do X for me”, maybe by reformulating the task. – Andreï Kostyrka Sep 3 '16 at 1:16
• Oh, and how are we supposed to test our code if we do not have this notebook model? Maybe this challenge should be more general? – Andreï Kostyrka Sep 3 '16 at 1:17

# Origami in One Dimension

In this restricted version of origami, the artist begins with an unfolded strip of paper n segments long, the segments labeled from 0 on the left up through n - 1 on the right. For instance, if n were 7, the unfolded strip of paper would look like this:

| 0 | 1 | 2 | 3 | 4 | 5 | 6 |


Then the artist repeatedly makes "mountain" folds, each time tucking the right side under the left, based on a sequence of crease locations S. These locations are given as integer distances from the paper's left edge.

For example, consider the sequence [3, 3, 0, 3]. According to it, the first crease in the paper above should be made three units from the left edge, so segments 3 through 6, to the right of the crease, would get tucked beneath 0 through 2 to the crease's left:

    | 0 | 1 | 2 \
| 6 | 5 | 4 | 3 /


The second crease is to be three units from the new left edge, so that fold would tuck the 2 and 3 under everything else:

    | 0 | 1  \
| 6 | 5 | 4 \ |
/ 3 / |
\ 2  /


The third crease should fall zero units from the left edge, meaning that the entire paper is to its right, and the whole thing gets flipped over:

 /  2 \
| / 3 /
| \ 4 | 5 | 6 |
\  1 | 0 |


And finally, the fourth fold falls on the paper's right edge, flipping nothing.

Thus, the completed artwork, when viewed from above, would read [2, 5, 6].

Write a program or function that, given the nonnegative integer n and a sequence of crease locations S, returns the sequence of integers visible on the final folded paper as seen from above. You may assume that all of the elements of S are in-bounds, though creases are allowed to fall on edges as above. Some randomly generated sample inputs and outputs:

0,  []                       -> []
1,  [1]                      -> [0]
2,  [0]                      -> [1, 0]
2,  [1, 0, 1]                -> [1]
3,  [0, 2]                   -> [2, 1]
3,  [3, 2]                   -> [0, 1]
3,  [0, 1, 0, 2, 2, 2]       -> [1, 0]
4,  [1, 1]                   -> [1, 3]
4,  [2, 2]                   -> [0, 1]
4,  [4, 2, 2, 0]             -> [2, 3]
5,  [3, 2]                   -> [0, 1]
5,  [3, 0, 0]                -> [0, 1, 2]
5,  [5, 0, 1]                -> [0, 1, 2, 4]
6,  [2]                      -> [5, 4, 0, 1]
6,  [5, 0]                   -> [5, 3, 2, 1, 0]
6,  [6, 1, 1]                -> [1, 2, 3, 5]
6,  [0, 2, 4, 3, 1, 0, 2]    -> [1, 5]
7,  [6, 1, 2]                -> [1, 6, 4]
7,  [3, 3, 0, 3]             -> [2, 5, 6]
7,  [7, 2, 0, 0]             -> [6, 5, 4, 0, 1]
7,  [3, 0, 0, 1, 2]          -> [3, 4]
8,  [3, 1]                   -> [3, 4, 5, 7]
8,  [3, 2, 3]                -> [3, 7, 6]
9,  []                       -> [0, 1, 2, 3, 4, 5, 6, 7, 8]
9,  [2, 1]                   -> [2, 3, 4, 5, 6, 8]
9,  [5, 1]                   -> [5, 6, 7, 0]
9,  [8, 4, 2, 0, 0]          -> [0, 1]
10, [3, 2]                   -> [3, 4, 5, 9, 8]
10, [0, 5, 5]                -> [9, 8, 7, 6, 5]
10, [0, 3, 1, 5, 2, 0, 0, 0] -> [4, 3, 2]


Rules and scoring are as usual for .

## Remaining Sandbox Questions

In addition to general feedback, I'd appreciate an input on:

• Is the revised specification clear?
• Is the barrier to getting started on this challenge low enough?
• Is there sufficient room here for a variety of approaches?
• Very neat challenge, but I think you should clarify some edge cases: 1) if the fold is done at 0, does that just rotate the entire paper 180 degrees? 2) Will the paper ever be folded onto other layers, e.g. at the end of your example, could there be a 1, and if so would the 2 go below the 0? 3) Will a fold ever affect multiple layers, e.g. 8, [4, 2] and if so are they folded individually or all together? I assume you've covered these in your test cases, but it would be great to see them in the worked example, so people don't have to reverse engineer these details from the test cases. – Martin Ender Aug 29 '16 at 7:59
• As for tags, I'd probably drop sequence. It's usually used for OEIS-like integer sequences, and you seem to be using it to refer to lists, which is covered by array-manipulation. – Martin Ender Aug 29 '16 at 8:00
• Revised per comments. – Edward Sep 2 '16 at 23:57

# Simulate World's smallest universal Turing machine

## Goal:

to implement world smallest automata which was proved (though, not strictly) to be able to simulate any other universal Turing machine, Wolfram's 2-state 3-symbol Turing machine & prove your language's Turing-completeness.

## Specification:

{{1, 2} -> {1, 1, -1}, {1, 1} -> {1, 2, -1}, {1, 0} -> {2, 1, 1}, {2, 2} -> {1, 0, 1}, {2, 1} -> {2, 2, 1}, {2, 0} -> {1, 2, -1}}

where this means {state, color} -> {state, color, offset}. (Colors of cells on the tape are sometimes instead thought of as "symbols" written to the tape.) Source

### "Word" description:

Think of this machine as an array processing function. This array has a pointer accessible by function. Every cell in this array can store an integer from 0 upto 2. Array is infinite from both sides & pointer is pointing to somewhere in the middle of this array. function itself has 2 modes. in each mode, it works different than other. Let's call these 2 modes "A" & "B".

if in state "A" :

• if the value of the cell pointed by pointer is 0, change it to 1 & increase pointer & toggle state;

• if the value of the cell pointed by pointer is 1, change it to 2 & decrease pointer;

• if the value of the cell pointed by pointer is 2, change it to 1 & decrease pointer;

if in state "B" :

• if the value of the cell pointed by pointer is 0, change it to 2 & decrease pointer & toggle state;
• if the value of the cell pointed by pointer is 1, change it to 2 & increase pointer;
• if the value of the cell pointed by pointer is 2, change it to 0 & increase pointer & toggle state;

(Increasing the pointer moves it to right.)

Your program's array must be at least (2^16+1) and when it goes out of boundary, pointer must come back from other side. Size of array must be either dynamic or odd (Which at first, pointer is pointing to middle element of array).

## I/O format

Though there aren't strict rules about input & output. Your program must at least get number of iterations as an input & output current pointer address (an integer, 0 at first, negetive if pointer gets decremented to subzero) & value of pointed cell along with a seprator (e.g. space) at every iteration. Though this is the minimal requirement.

## Winning criteria(s)

There aren't many restrictions about challenge itself. But for wining, you'll need to get other users' votes. You can try to make an optimized system, or simulate it in a strange language, or have an strange design. But you mustn't add anything extra to machine itself, and must be able to produce the exact state of pointer and tape in a particular iteration.

• This looks like a "be creative" popcon, which should be avoided. Why popcon rather than an objective winning criterion? – Peter Taylor Sep 4 '16 at 7:31

# The number 3 is cursed; avoid it

Inspired from this

It's well know that the number 3 may lead to weird bugs in a program. So your task is to write a program to remove every literal 3 (only the base 10 number; not a 3 in a string, a variable name, a longer number or with a different base) in a source code written in the language of your program by the floor of π.

But you can't have the character 3 anywhere in your source code.

You can't use a language without number literals.

### Test cases (source language: Python)

print(3)
=>
import math
print(int(math.pi))

print("3 * 1 = %d" % 3)
=>
import math
print("3 * 1 = %d" % int(math.pi))

var1 = var2 = 33
var3 = 3 * var1 + var2 * 3
print("3 * %d + %d * 3 = %d" % var3)
=>
import math
var1 = var2 = 33
var3 = int(math.pi) * var1 + var2 * int(math.pi)
print("3 * %d + %d = %d" % var3)

print(0x3)
=>
print(0x3)


Since this is , the shortest answer in bytes win. Good luck!

• So the empty brainfuck program wins? – Dennis Sep 3 '16 at 18:10
• 1. There isn't a clear definition of esolang. Also, it makes no sense to disallow a huge number of programming languages, just because a small subset of them trivializes the problem. 2. What about 0x3, 0o3 or 0b11 in Python? Those are also numeric literals that represent 3. 3. What is the language in question doesn't have a built-in for Pi? 4. What counts as flooring? Python's int doesn't floor, although it happens to work that way for pi. – Dennis Sep 3 '16 at 19:18
• Why is there a language restriction at all? – Beta Decay Sep 3 '16 at 20:20
• @βετѧΛєҫαγ To prevent 0-byte brainfuck answer – TuxCrafting Sep 3 '16 at 20:21
• Should the resulting program run/compile? For example, the Haskell code 3 + 1.0 works, but floor pi + 1.0 gives a type error. Can we add additional code to fix such things (-> fromInteger (floor pi) + 1.0)? – nimi Sep 3 '16 at 22:08
• @nimi Yes you can – TuxCrafting Sep 3 '16 at 22:24
• I guess, the resulting program should run/compile and do exactly the same as the original program (maybe you should note this explicitly). There are far more exceptions where a replacement will fail than in your list (not a string, not a variable name, etc). Examples are Basic's line numbers or Perl's format which has literal text without being a string. I doubt one can name them all. You can argue that not all languages are suited for this task, but then why make exceptions at all? – nimi Sep 4 '16 at 9:27

# Output a confusion matrix

A confusion matrix is a pretty typical thing to see in a machine learning paper. It is a matrix where each cell contains the number of instances of the class of the row that were classified as the class of the column.

For example, if we have two classes A and B, and 4 instances [A, A] (meaning that instance is of class A and was classified as A), [A, B], [B, B] and [B, B], then the resulting confusion matrix would be:

  A B
A 1 1
B   2


TODO: more details about the format, what happens if the name of the classes have different lengths, etc. etc.

# Output a number tent

tags:

Given an integer, output a number tent. (The number tent is just called as such.)

The input determines:

• whether the tent is upside down (negative) or right way up (positive),
• whether the entrance is on the left side (even) or the right side (odd), and
• the size of the tent (abs(input/2) http://mathurl.com/hwkkw3f.png with integer division).

For input -4:
________
\  /   /
\/___/


Assume that the input will never be 1, 0 or -1.

TODO Clarify.

Your code should be as short as possible.

• Input of 1 should return an empty string (as should -1 and, of course, 0, although we should clarify that size is abs(input/2) with integer division). Tag suggestion: ascii-art – Jonathan Allan Sep 7 '16 at 18:18

# Auto golf a string

Your objective is to make a program (written in a language of your choice) that takes arbitrary strings as input and outputs a program in a constant target language that, when run, prints that string. The original program does not have to be golfed, but the output programs should be in some way optimal or nearly optimal.

Voters are encouraged to keep the following points in mind when voting:

1. How difficult is the target language to program in? Is it on par with languages such as Brainfuck and whitespace, or is it something trivial, like Python or Ruby?
2. How efficient is the golfer? That is, how does it compare to any existent auto string golfers? And how does it compare to hand-golfing?

## Meta

Okay, so this isn't our usual type of challenge, but I think this could really turn out well. However, I think this is underspecified as it is, and would appreciate feedback.

• This may overlap with some other metagolfing questions... That will mean that any future kolmo meta-golfing qs will be dupes. – Beta Decay Sep 11 '16 at 20:00
• @BetaDecay Yeah, but only in reference to strings – Conor O'Brien Sep 11 '16 at 21:06
• This is a bad fit for a site with a 30000 character limit to answers. I would have to golf 12kB off my GolfScript-Kolmogorov program to fit it in an answer even without any explanation beyond the comments in the code. – Peter Taylor Sep 12 '16 at 11:12
• @PeterTaylor that is certainly impressive. How substantial are the reductions? – Conor O'Brien Sep 12 '16 at 11:14
• – Peter Taylor Sep 12 '16 at 11:25

# Balanced use of the alphabet

Write a program that counts from 1 to 100 and back down and ends by the sentence "I finished counting":

1, 2, 3, ... 97, 98, 99, 100, 99, 98, 97, ... 3, 2, 1, I finished counting

The output can be of any kind: array, comma separated, line separated, ...

In order to do that, your code reviewer (who has a wierd OCD) won't accept code that doesn't contain the same amount of each letters of the alphabet.

He also doesn't accept code with no letter at all because, you know... letters are cool.

## Scoring

Your score will be codeLength * (mostRepresentedLetter / leastRepresentedLetter).

## Example of scoring

for(int i=1;i<=100;i++){abcdefghijklmnopqrstuvwxyz();}


Length: 39
Most represented letter: i (5 times)
Least represented letter: a (once)
Score: 39 * 5 / 1 = 195

NOTE: if a letter is not at all present, divding something by zero will make an inifinite score. As this is , it is not something you want.

• As written, what prevents folks from just putting any extraneous letters behind a comment? How would code that doesn't use ASCII, like APL or Jelly, be scored? – AdmBorkBork Sep 12 '16 at 13:40
• Since the scoring isn't based solely on code length, maybe [code-challenge] is more suitable. – Geobits Sep 12 '16 at 20:07

## Validate the traversals

Given inorder and preorder traversals of a binary tree, return a truthy or falsy value depending on whether they could be from the same tree.

Input can be strings of characters or arrays of characters or numbers, whatever is the most convenient. You can assume both inputs are the same length.

Examples:

inorder: A
preorder: A
result: true
example:
A

inorder: AB
preorder: AB
result: true
example:
A
\
B

inorder: AB
preorder: BA
result: true
example:
B
/
A

inorder: ABC
preorder: BCA
result: false
possible inorder trees:
C   C   B   A   A
/   /   / \   \   \
B   A   A   C   C   B
/     \         /     \
A       B       B       C
CBA  CAB  BAC  ACB  ABC


This is , so the shortest solution wins.

• The test cases should include some which repeat characters. – Peter Taylor Sep 12 '16 at 13:39
• @PeterTaylor I'll have to make it clear in the question that the characters won't be repeated, as they're supposed to refer to different nodes in the tree. – Neil Sep 12 '16 at 13:54

# Illuminati is Illuminati

This is a popularity contest inspired by a dedicated scratch programmer who made the program here: https://scratch.mit.edu/projects/117836320/. What the program does, is it takes in a string, and links the string to the Illuminati. This scratch program is especially popular because it demonstrates meta-satire on linking things to other things.

## challenge

Your job is to more or less produce something of similar function and form to the one linked above.

## Input:

Your program can take anything as an input, however, it has to be able to take something. My suggestion is a string.

## Output:

The last output of your program must be some variation of [input] + " is Illuminati confirmed."

## Scoring:

This is a popularity challenge. Your code isn't supposed to look great, or even execute well, so long as it has the most up votes. You must use a code that has a free compiler, and you must post your source code along with your program.

# Tips and tricks:

This section will be updated, as people post suggestions in the comments.

• Unlike what the program listed above does, there are many more links to have done besides the number of letters an a string. try looking for anagrams, or similar words.
• A question should ideally be self-contained. Without reading the external link, which could 404 tomorrow, I have no idea what you want the program to do. – Peter Taylor Sep 14 '16 at 10:03
• @PeterTaylor the link will not 404. it's a permalink..... and you should know what I want it to do, I put in my post "What the program does, is it takes in a string, and links the string to the Illuminati." and "Your job is to more or less produce something of similar function and form to the one linked above." – user56309 Sep 14 '16 at 14:03
• Seems humorous, give some examples. Also be more specific on what "links the string to the illuminati" means. – NonlinearFruit Sep 14 '16 at 14:43

## Translate an SVG path

An SVG path consists of a number of components. Each component begins with a letter, which may be upper case for an absolute position or lower case for a relative position. The component then has a variable number of parameters. Parameters may be separated by commas or spaces.

For the purposes of this question, you will not need to support the H, L or A commands. This means that each component accepts an even number of parameters, and that alternate parameters refer to the X and Y coordinates.

Given an SVG path and X and Y displacements, please output the translated path.

Input and output should be in any reasonable format, as long as you are consistent, i.e. both coordinates should be in the same format, or they can use a Point type, while the output path should be in the same format as the input path.

Please avoid floating-point errors e.g. adding 0.1 to 0.1 and getting 0.199996 like Inkscape does when I asked it to do this.

Example:

Input:
6.4
6.4
M 6.4 12.8 L 19.2 25.6 l 6.4 -6.4 z

Output:
M 12.8 19.2 L 25.6 32 l 6.4 -6.4 z


This is , so the shortest program wins.

• Does "exact arithmetic" mean use of floating point is forbidden? – trichoplax Sep 14 '16 at 14:05
• @trichoplax By "exact arithmetic", I mean that you should ensure that you don't introduce floating-point accuracy errors in your output. The input list may be absolute or relative depending on whether the command letters are in upper or lower case. Relative coordinates do not need to be adjusted, of course. – Neil Sep 14 '16 at 14:53
• It's worth including a summary of what commands need to be supported, and how each works. – trichoplax Sep 14 '16 at 15:14
• Using floating point variables will introduce floating point errors for some values. Do you want to specify a minimum required accuracy, or do you want to insist on only number types that do not share the problems of floating point? – trichoplax Sep 14 '16 at 15:17
• The numbers won't need huge amounts of accuracy, so I don't care how you represent the numbers internally, as long as the output contains no floating-point errors. – Neil Sep 14 '16 at 15:56
• The problem is it's hard to avoid floating point errors without knowing what accuracy the inputs will have. – trichoplax Sep 14 '16 at 16:01

# Pointfree Generator -- this is a draft.... --

## What is this?

From Wikipedia's page:

Tacit programming, also called point-free style, is a programming paradigm
in which function definitions do not identify the arguments
(or "points") on which they operate


## Challenge

In this challenge, you will have to generate Haskell code in pointfree style. You can provide an answer in any language of your choice as long as it generates Haskell code.

The functions to generate will be polynomial function of multiple variables with integer coefficients like : f : x,y,z -> x^8*y*z + 3*y + 12

for example, the function f : x -> x² + 3x can be written in pointfree Haskell like this (3*)>>=flip((+).(^2)) or (+3)>>=(*)

## Input

The input is a list of list of coefficients and exponants : For example, the f : x,y,z -> x^8*y*z + 3*y + 12 function will be defined as [[1,8,1,1],[3,0,1],[12]]

## Restrictions

Haskell function/operators allowed are the following : (+),(-),(*),(.),(^),flip,(=<<),(>>=)

# Pitchers and Rivers

Credit for the idea for this challenge goes to Dan Garcia of UC Berkeley.

Many of you may have heard of any number of variations on the pitcher problem. For those who haven't, or need a refresher, the generalized form of the pitcher problem is as follows:

Given a list of pitchers of known size and a river filled with infinite water, how can you obtain a specific amount of water?

For a more specific example:

Given a 3-liter pitcher, a 7-liter pitcher, and a river, you can obtain exactly 2 liters as follows:

1. Fill the 3-liter pitcher.

2. Pour the 3-liter pitcher into the 7-liter pitcher.

3. Repeat steps 1 and 2 again twice.

4. If you didn't spill any extra water when filling the 7-liter pitcher the third time, the 3-liter pitcher will now contain 2 liters.

You cannot pour out part of the pitcher unless you can measure how much you poured out by filling something else up, e.g. another pitcher.

Your goal, now, is to determining which amounts of water you can get from your pitchers, given their sizes... but generalized to any number of pitchers.

## Input

You will receive the pitcher sizes in any reasonable format. A (non-exhaustive) list of examples are:

1. A newline-separated list. 5\n13\n532

2. A Pythonic list. [3,7,13,22]

3. Prompt for input, like BF's .[>.]

You do not have to handle invalid input (e.g. negative sizes, empty lists)

## Output

A list of obtainable (measurable) amounts of water, in any reasonable format. You may include 0, but you do not need to. You do not need to list the steps by which you obtain these quantities.

[3,5] -> [1,2,3,4,5,6,7,8]

[3,3] -> [3,6]

[4,6] -> [2,4,6,8,10]

[7, 5, 3, 2] -> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]

[30, 15, 5] -> [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50]

[5,0] -> [0, 5]

[-1] -> Undefined behavior; sizes are always positive


Reference solution in Pyth, barely golfed (100 bytes)

• I would suggest [4,6] -> [2,4,6,8,10] as another test case. – El'endia Starman Sep 14 '16 at 1:25
• This has been asked before, although it's closed and definitely abandoned. It would be nice to ensure that your spec is compatible with the two existing answers and see whether the mods will merge the old question into the new one. – Peter Taylor Sep 14 '16 at 7:37
• @PeterTaylor The goal of this challenge seems very different from the one linked; that one asks for the list of steps to get a specific target goal and mine asks what target goals are reachable. Also, my question allows for multiple pitchers to be combined in order to get the measurements, while that challenge requires that all the water end up in one pitcher. I believe these are two completely different challenges. – Steven H. Sep 14 '16 at 9:26
• "that one asks for the list of steps to get a specific target goal and mine asks what target goals are reachable" are fundamentally the same thing. The algorithm is identical: the only difference is the output format. "Also, my question allows for multiple pitchers to be combined in order to get the measurements" Does it? I can't see that in the question. – Peter Taylor Sep 14 '16 at 10:06
• The major difference is that mine doesn't require you to compute the steps (as there are characterizations of these lists that do not involve computing individual steps; part of the challenge may be finding these characterizations.) I didn't include anything saying that you may combine the pitchers because, at the time, I hadn't thought that the distinction would need to be made. However, in the sample outputs you can notice that I include values up to the sum of the pitcher sizes, as opposed to up to the maximum pitcher size. – Steven H. Sep 14 '16 at 10:18
• Is the solution just multiples of the gcd up to the sum of the inputs? If not, you need test cases that show this. – xnor Sep 14 '16 at 17:17
• @xnor, to be honest, I don't know for sure. What test cases would you recommend, though? – Steven H. Sep 14 '16 at 17:23
• I'd strongly suggest figuring out a solution or having a reference implementation to generate lots of cases before posting this to avoid disagreements as to whether a submitted solution works. – xnor Sep 14 '16 at 17:33
• @xnor A reference solution has been added. Anything else I should add? – Steven H. Sep 14 '16 at 23:27
• @StevenH. You should add more test cases, especially ones with more inputs, ones that given unexpected results, ones that break the gcd pattern if they exist, etc – xnor Sep 14 '16 at 23:36
• All the examples I tried on the Pyth app follow the gcd pattern. You could try iterating or generate random examples to look for exceptions. I found proofs that it holds for 2 jugs, maybe one can induct the same onto n jugs. (Edit: This paper proves it) If it holds, I think that's unfortunate because it gives a simple direct solution that doesn't require doing anything specific to the bucket problem. Maybe you could require more output. – xnor Sep 14 '16 at 23:45
• @xnor how about mapping all the reachable bucket states to their total amount of water? I'd submit the (slightly modified) Pyth solution as an actual answer in that case. – Steven H. Sep 14 '16 at 23:56
• What mapping do you mean? Could you give an example? – xnor Sep 16 '16 at 3:29
• Unfortunately it seems that someone posted almost the same challenge now (presumably unknowingly). – Martin Ender Sep 22 '16 at 18:14

## Code Golf: Convert to base 6 and back

If given a number, convert it to base 6. You can assume it is positive. You can get the number through any of these methods: STDIN, or ask for user input. If i has a 'o' at the end of it then assume the number is base 6 and convert it to a decimal number. Assume i is a string.

Example: Given i convert it. So if i = 12 then return 20. Given i convert it. so if i = 12o then return 8

• I don't think this really adds anything to the dozens of base-conversion challenges we already have and is likely to be closed as a duplicate of one of the simpler ones. – Martin Ender Sep 17 '16 at 11:49

# Quine and Antiquine

Your task is to make two different program, A and B. Both are nonempty proper quine. However, there is a restriction.

1. AB and BA produce no output.
2. CABD and CBAD will do the same thing as CD, where C and D are any (potentially empty) strings made up of copies of A and B. E.g. ABBABA and ABBBAA should behave identically (here, C = ABB and D = A).

The score is the sum of the length of A and B.

Example:

A program written in DJam:

program A :

abcd


program B :

efgh


Then, these output are sastified

abcdefgh
>> <empty output>
abcdabcdefgh
>> abcd
abcdabcdefghabcdefgh
>> abcd

• Are proper quines required? Do A and B have to be different? – Dennis Sep 16 '16 at 18:40
• "where C and D is any string, if C and D consist entirely of A and B." I don't understand this part, would you mind rephrasing it? – Martin Ender Sep 17 '16 at 11:48
• @MartinEnder Sorry if my English is not good. But I mean string S where S = e | S A | S B where e is empty string. – Akangka Sep 18 '16 at 7:52

## Periodic Pillbox Problem code-golf

Pill-popping Patty is prescribed to take a particular pharmaceutical every P days. Presently, Phil has punked Patty's pill-box, punching holes in particular weekday's plastic pockets. Patty proceeds to plan pills P days apart whenever possible, but places pills in the preceding day's plastic pocket if the preferred pocket is punctured. Produce a pill planning chart presuming Patty popped her prior pill on the penultimate day of the previous week.

In case it's not clear, this is the kind of pill-box I am referring to.

Input:
The number P, followed by the 1 to 6 weekdays that Phil punctured. Beginning with Sunday(N) the weekdays are N M T W R F S. For instance 5MRF means Patty aims to wait 5 days after each pill, but cannot plan pills on Monday, Thursday, or Friday.

You can have the input with a single space after the number (e.g. 5 MRF) or with spaces after the number and each day (e.g. 5 M R F).

Process:
Given 5MRF Patty's first pill is taken on the first Wednesday (5 days from last Friday). Her second pill should be taken on the second Monday(5 days from the first Wednesday), but is moved up to the second Sunday because Monday is punctured. Her third pill should be taken on the second Friday(5 days from Sunday, not Monday), but is moved up to the second Wednesday because Friday and Thursday are both punctured. She continues in this manner indefinitely.

Note on the first week Patty's pillbox contains one pill on Wednesday, on the second and future weeks it contains pills on Sunday and Wednesday.

Output:
The pill planning chart shall indicate the state of Patty's pill-box each week, one week per line. Days she does not take her pill must have a dot ·. Days she takes her pill must have a capital X. The chart must stop as soon as the cycle occurs (i.e. in the fewest lines possible) with an arrow > pointing the first week in the cycle on the left. All weekdays must align in singly spaced columns with Sunday on the left.

Notes:
You may assume Phil was not malicious enough to puncture P consecutive days of the weeks, and that P is between 2 and 7 inclusive.

If Patty can't take her pill on the first Sunday, she takes it on the previous Saturday. Her pillbox was not damaged last week.

A cycle has occurred when pills are being taken on the same weekdays as in an earlier week.

Patty never waits more than P days to take her pill.

Testcase 1: 5MRF

  · · · X · · ·
> X · · X · · ·


Testcase 2: 5MR

> · · · X · · ·
X · · · · X ·


Testcase 3: 5MF

  · · · X · · ·
> X · · · X · ·
· · X · · · ·


Testcase 4: 6NTFS

  · · · · X · ·
> · · · X · · ·
· X · · X · ·


A reference solution in C++ is provided here.

For The Sandbox...
First Challenge. Hooray! My biggest concern is whether or not there is anything with a similar process, I'm not sure if there is a generalization or a name for this sort of elimination thing. Barring that, is a good golfing question, can it be made a better golfing question, is clear what has to be done, etc. Really any advice is welcome.

• 1. "For instance 5MRF means Patty aims to wait 5 days after each pill, but cannot plan pills on Monday, Thursday, or Friday." So what does that mean in terms of the actual days in which she takes the pill? I think that she ends up taking them too frequently rather than averaging out in the long-term, but I had to try to figure that out by reverse engineering the test cases. 2. "followed by the 1 to 6 weekdays that Phil punctured ... P is between 2 and 7 inclusive" seems contradictory. – Peter Taylor Sep 21 '16 at 10:54
• @PeteTaylor, Okay... I've added a plain English example of the process. Yes, Patty takes her pills too often. To point 2, I don't see the contradiction, P is the days she waits to take a pill, not how many days Phil punchs. Her process would never work with say 1W, or 7NMTWRFS. – Linus Sep 21 '16 at 16:02

# Checkmate (aka the urinal problem) V2

inspired by Checkmate (aka the urinal problem)

given a non-negative integer n, assume there are n urinals.

also assume that you are not allowed to use an urinal when

• it is out of order.
• or a neighboring urinal is occupied.

If no urinal is available, the situation is considered checkmate.

Challenge:

Create a program or function that finds and prints (or returns, or yields) all possible checkmate combinations for n urinals.

Input: STDIN, command line argument or function argument

Output: Any output that makes the combinations clear is accepted.

TODO: add visual and test cases.

a thought:
This cries for string operations; how about a bonus for a calculational solution? Do bonuses suck?

• You say "out of order" but then don't mention it again. How does that change things and how is it given in input (if it is)? – Geobits Sep 21 '16 at 20:12
• @Geobits I hope the edit clarifies. – Titus Sep 21 '16 at 20:20
• Yes, bonuses suck. – m-chrzan Sep 22 '16 at 2:26
• Do you have a reference implementation? Have you checked for the sequence on OEIS? (I ask the second question because once I saw the OEIS page for yesterday's urinal challenge I was tempted to vote to close as a dupe of a Fibonacci question because the sequence was so similar). – Peter Taylor Sep 22 '16 at 17:17
• @PeterTaylor: not yet. and: I don´t even know OEIS. Why should I check it? – Titus Sep 22 '16 at 18:36
• The Online Encyclopaedia of Integer Sequences is the biggest repository of integer sequences that I know of. Whenever an integer sequence question is asked, people will look there for formulae. Now: having re-read this question and on the assumption that any number of urinals can be out of order, this is asking for sequences of length n over the alphabet 01 avoiding the substring 11. They're counted by the Fibonacci numbers, so there's a good chance that there's an earlier question close enough to be a duplicate. – Peter Taylor Sep 22 '16 at 20:38
• I believe f(n) = f(n-1) + 3f(n-2) + 2f(n-3), with some boundary conditions. – m-chrzan Sep 22 '16 at 21:01

Compute The anti-derivative of a non-constant function

Most of us know how anti derivatives work. They are basically the sums of infinite number of very small elements (or units).

The challenge here is to calculate anti derivative of a function (NON CONSTANT). using any programming language except the ones which calculate anti derivatives directly (Mathematica for instance).

Anti derivatives which have been calculated must be done by the usual summation method which is basically the definition of the integral. Summation of y.dx over some interval of x)

You basically have to find the anti derivative WITH limits i.e. definite integral of a non constant function in between two user specified limits

• As it stands this would get closed very quickly as "Unclear what you're asking". Even at the very basic level of whether you want symbolic or numeric integration, there are hints pulling in opposite directions. Either way, you need a specification of the input format; if you want quadrature you need to specify constraints on the rule; and you need to avoid duplicating codegolf.stackexchange.com/q/2072/194 and codegolf.stackexchange.com/q/66714/194 – Peter Taylor Sep 23 '16 at 20:06
• I though the challenge is about finding a sybolic anti-derivative, not a numeric definite integral. – Vi. Sep 24 '16 at 6:33

Your boss wants you to make a comprehensive download utility. She uses Microsoft Bob and thinks shorter code is better code.

The Gist: In as few bytes as possible, given an input URL, output the file to stdout.

### Input

• You will be given a fully qualified (w/ http/https) URL.
• Any non 2xx-3xx status code should be interpreted as an error. Exit with a status code of zero.
• Verify SSL certificates - exit with 0 if invalid

### Misc

• Do not use a preexisting utility already designed for downloading files, such as wget. This is considered cheating.
• I'd consider this a chameleon challenge. Validating an SSL certificate is harder than all other parts combined. It also needs some clarification. Which SSL certificates are considered valid? – Dennis Sep 25 '16 at 17:32
• @Dennis hm, libraries should exist... – noɥʇʎԀʎzɐɹƆ Sep 25 '16 at 18:03
• 1. For those languages which do have SSL libraries (which isn't all of them), there are often options. E.g. there could be an option to accept or reject self-signed certs. There could be an option to accept or reject certs whose chain includes MD5 or key sizes smaller than 256 bits. Those options may vary between libraries or distros. So Dennis is right to ask for a clear definition of "valid". 2. What's the distinction between libraries which do that level of checking and "a preexisting utility"? – Peter Taylor Sep 25 '16 at 21:41
• Someone might download a virus... – Erik the Outgolfer Sep 28 '16 at 12:42

# Handwriting Recognition

The MNIST dataset is a series of handwritten digits used as a standard testbed for machine learning, pattern recognition techniques. Each image is of a single digit, 0-9; as a 28x28 pixel grayscale matrix with values from 0-255.

The challenge is to create a classifier for MNIST that scores an Error Rate of less than [TBD] in the least number of bytes possible.

Your program must take a 28x28 2d array in whatever format is applicable for your language representing a single image. For example, the input for the first digit might be:

[[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3, 18, 18, 18,126,136,175, 26,166,255,247,127,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0, 30, 36, 94,154,170,253,253,253,253,253,225,172,253,242,195, 64,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0, 49,238,253,253,253,253,253,253,253,253,251, 93, 82, 82, 56, 39,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0, 18,219,253,253,253,253,253,198,182,247,241,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0, 80,156,107,253,253,205, 11,  0, 43,154,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0, 14,  1,154,253, 90,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,139,253,190,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 11,190,253, 70,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 35,241,225,160,108,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 81,240,253,253,119, 25,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 45,186,253,253,150, 27,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 93,252,253,187,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,249,253,249, 64,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 46,130,183,253,253,207,  2,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 39,148,229,253,253,253,250,182,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 24,114,221,253,253,253,253,201, 78,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0, 23, 66,213,253,253,253,253,198, 81,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0, 18,171,219,253,253,253,253,195, 80,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0, 55,172,226,253,253,253,253,244,133, 11,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,136,253,253,253,212,135,132, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]]


## Conditions:

• This is code golf. The shortest piece of code that meets the criteria wins.
• The code must take a provided 28x28 input and attempt to classify it.
• Testing will take place on my computer at 12pm AEST on Saturday the . I will run each classifier over a set of 1000 images. To be considered, it must correctly classify [TBD] of them. If I can't get your code to run, it wont be counted, so help with loading the images in your language would be appreciated.
• Standard loopholes are not permitted.

# Questions for Sandbox

• Overall thoughts on the challenge?
• Has anything been done like this before? Did it work?
• Any ideas on a good cutoff for the classifier? I was thinking around 60% correct. Though was going to have a go at it myself to see what I could reasonably achieve.
• Does the testing clause make sense? Is it reasonable? Should I put a limit on the languages?
• Since barrier to entry is a bit high (knowing how to get hold of the images, possibly some ML experience), is there anything extra I should do to make it easier to start the challenge.
• This is my first suggestion for a challenge, is there anything I'm missing?
• I actually found a very similar question from back in 2014 (using MNIST). It had a different scoring system and some slightly different criteria and expectations. Is this still worth it? Is it late enough for others to have another go? – SCB Sep 26 '16 at 3:36
• I don't think it's sufficiently different. If you want to provoke others to have another go, you can do so in the chat or by placing a bounty on the existing question. – Peter Taylor Sep 26 '16 at 13:44
• 60% correct is way too leniant; current state-of-the-art techniques on this dataset "easily" reach 99+% of correct classification. – Fatalize Sep 28 '16 at 11:48
• Unrelated, but I would like to congratulate you on submitting the 3000th answer to the Sandbox! (That number includes all deleted submissions.) – PhiNotPi Sep 28 '16 at 15:12
• @Fatalize I was thinking 60% because I wanted the emphasis to be on the code-golfing, not the machine learning. If it's lenient enough I'm hoping someone can figure out some really, really simple way that would just scrape in. All in the spirit of code golf. – SCB Sep 28 '16 at 23:02
• @PeterTaylor I was hoping that the idea of a hard limit would switch the challenge around so it's not focused on building a function that works well, but instead building a very short function that works, barely. In the original a slight improvement in code length that decreased the correct matches would be bad, whereas in this challenge decreasing the code length is always good, as long as you still sit above [TBD] correct images. – SCB Sep 28 '16 at 23:09

# Gif - Jif, Jif - Gif

The point of this challenge is to (not) settle debate on the pronunciation of "gif" http://38.media.tumblr.com/11bc6092d29c8c6840f9e10184ca03fd/tumblr_mlksz8SLjn1qz4h3co1_1280.gif

The pronunciation of gif is debated and while it's supposed to be (and should be) pronounced jif, it's still commonly disputed.

In this challenge you will be given a set of words that have a g or j, representing the sound that the word is pronounced with. You'll also get some text in which you have to fix the incorrect spellings of gif.

Because this is the internet and everyone always wrong. It's (not) common courtesy to correct them.

An example of a wrong pronunciation would be:

There was a gif of a mouse eating a burrito

The wrong spelling of gif? Unacceptable! This must be corrected immediately:

There was a jif (as in jar) of a mouse eating a burrito

Are we done? Nope, you're still wrong.

This must work the other way:

In the jif the cat wore a hat of a cat

This obvious misspelling must be fixed, we shall correct this to:

In the gif (as in graphic) the cat wore a hat of a cat

### Rules

• You may assume all words that contain the letter g have the hard g sound (as in gravy) and all words that contain the letter j have the j sound (as in jam)
• Words will never have both g and j (Will add more specific rules later)
• Words must be picked at random each item with the same chance of being picked
• Words may be supplied through an array or the closest alternative for your language.
• Case must be preserved E.g. GiF -> JiF.
• You may write a program or a function

### Examples

Input and output separated by a single line:

graphic, jar, jam, gram
I saw a jif of how to pronounce gif that showed gif is pronounced jif

I saw a gif (as in graphic) of how to pronounce jif (as in jar) that showed jif (as in jam) is pronounced gif (as in gram)


gravy, jeff
G is for gif, h is for jif, i is for gif, j if for jif

G is for jif (as in jeff), h is for gif (as in gravy), i is for jif (as in jeff), j is for gif (as in gravy)

• Is the assumption that, if there's more gif/jifs than input words, that you cycle through the g and j words independently (i.e. for gravy, jar, jam, gram, you cycle through gravy, gram for jif and jar, jam for gif)? And do we have do anything special for soft g words, e.g. generate? – Sp3000 Oct 23 '15 at 12:28
• @Sp3000 forgot to specify that. I've made it so all words containing "g" are the hard g sound – Downgoat Oct 23 '15 at 22:49
• "Words must be picked at random" from what source? – Peter Taylor Oct 24 '15 at 8:49
• Has this challenge been posted? If not, may I take control of it? – Neil A. Jun 5 '17 at 23:09
• @NeilA. You may but I don't think it'll be well received because it's a simple find/replace – Downgoat Jun 6 '17 at 21:47
• @Downgoat: I will make a new answer with the same core idea but a few changes. Feel free to delete this if you wish. – Neil A. Jun 6 '17 at 21:52

## Largest Number Given Digits and Operators

Challenge

Given a list of digits (0-9) and operators (+, -, /, *), output the largest number that can be formed using those digits and operators, as well as the mathematical formula used to create this number.

Rules

• All digits and operators must be used once and only once
• Parenthesis may be used in the outputted mathematical formula
• The outputted mathematical formula must be valid in an interactive Python shell (Note, this means ["--", "---", etc.], "//", "**", and ["++", "+++", etc.] are all valid operations that can be used in the output)
• Base 10 will be used
• For multiple different formulas that result in the same maximum number, output whichever one
• Input may contain any number of digits and operators
• Answers can be a function or program, and will be scored in bytes
• No loopholes or built-ins

Example I/O

Input: [1, 4, 3, *, +]
Output: +31*4
124

Input: [1, 2, 0, '+']
Output: +210
210

• won't all pluses be at the front of the output? – Destructible Lemon Sep 28 '16 at 2:30
• This is rather similar to a number of existing questions, and may be closed as a duplicate. If you want to try to get it ready to post regardless, the use of the word "operators" in the first sentence is misleading given the later reference to combining those characters to form operators like **; and the question needs a complete list of permitted operators and what they do. People shouldn't have to find a Python language reference to know what // means, for instance. – Peter Taylor Sep 28 '16 at 8:47
• – Simply Beautiful Art Jul 31 '17 at 23:22

# Interleave your code with the input

Given an input string, interleave this string with the source code of your solution.

For example, if your code is abcd and the input is 1234, then your program must output 1a2b3c4d.

If your code is shorter than the input, then it must loop back to the beginning of your code. For example, if your code is abcd and the input is 123456, then your program must output 1a2b3c4d5a6b.

If your code is longer than the input, then only part of your code will be interleaved with the input. For example, if your code is abcd and the input is 12, then your program must output 1a2b.

### Inputs and outputs

• The input string will only contain characters which are valid string characters in your language.

• The input may be taken through STDIN, as a function argument, or anything similar.

• The output may be printed to STDOUT, returned from a function, or anything similar.

### Scoring

This is , so the shortest answer in bytes wins.

• I'm not even sure that this is possible. – Fatalize Sep 28 '16 at 12:01
• Why would it not be possible? The only potential problem I see is being closed as a dupe for being a straightforward generalised quine. – Peter Taylor Sep 28 '16 at 12:05
• @PeterTaylor I don't understand how being a "straightforward generalised quine" makes it a dupe (of what?). I don't see how this is more straightforward than say this challenge nor do I think it is a dupe simply because source code is involved. – Fatalize Sep 28 '16 at 12:09
• meta.codegolf.stackexchange.com/a/8595/194 – Peter Taylor Sep 28 '16 at 13:28

# The one-looper ASCII box

### Intro

I saw this one in one of my university programming textbooks as an "advanced" exercise and I thought it would fit very well here.

Your program have to ask for an input number and draw a box with the size of the given number and a cross in it.
Example if the number is 7:

+-------+
|\     /|
| \   / |
|  \ /  |
|   X   |
|  / \  |
| /   \ |
|/     \|
+-------+


Example if the number is 10:

+----------+
|\        /|
| \      / |
|  \    /  |
|   \  /   |
|    \/    |
|    /\    |
|   /  \   |
|  /    \  |
| /      \ |
|/        \|
+----------+


The minimum width is 1 and it looks like this:

+-+
|X|
+-+


Notice that with an odd size, there is an X in the middle.

### The hard part

In your program only one function is allowed (main) and in the main function there can be only one loop and that loop can only have one statement which can't be if. The shortest answer wins!

note: Sorry for the messy description but I had to translate it from my native language.

• I'd recommend removing the "C-only" part. – wizzwizz4 Sep 29 '16 at 18:23
• Language specific challenges are discouraged, as per meta.codegolf.stackexchange.com/a/8058/48538. Good luck. – user48538 Sep 29 '16 at 18:27
• do X without Y is confusing, especially when some internal things in languages use loops to achieve certain functionallity – downrep_nation Sep 29 '16 at 20:42

## Interpret loose ranges code-golf

ListSharp is an interpreted programming language that has many features, one of those features is a 1 index based range creator that works like this:

You define a range as (INT) TO (INT) or just (INT) where both or the single int can go from min to max int32 value

Then you can use those ranges to extract elements of an array without fearing to overstep it's boundaries

therefore:

1 TO 5 generates: {1,2,3,4,5}

3 generates: {3}

Ranges can be added up using the AND operator

1 TO 5 AND 3 TO 6 generates: {1,2,3,4,5,3,4,5,6}

remember this works with negative numbers as well

3 TO -3 generates: {3,2,1,0,-1,-2,-3}

# The challenge is the following:

## Input

A character array and the previously defined range clause as a string

## Output

The elements at the 1 index based locations of the range (non existing/negative indexes translate to an empty character)

# How to win

Create the program with the shortest byte count

## Test cases:

input array is:
{'H','e','l','l','o',' ','W','o','r','l','d'}

range clause:
"1 TO 3" => {'H','e','l'}
"5" => {'o'}
"-10 TO 10" => {'','','','','','','','','','','','H','e','l','l','o',' ','W','o','r','l'}
"0 AND 2 AND 4" => {'','e','l'}
"8 TO 3" => {'o','W','','o','l','l'}
"-300 AND 300" => {'',''}

• What is the winning criterion? – acrolith Sep 29 '16 at 20:49
• correct, i forgot that! its code-golf and i dont know how to add the tag – downrep_nation Sep 29 '16 at 20:50
• You can place [tag:code-golf] near the title. – acrolith Sep 29 '16 at 20:51

## Balanced Columns

I have a number of paragraphs of various heights which I would like to be distributed between some columns as evenly as possible. Here evenly means that you should minimise the total height of the tallest column, and then maximise the height of the shortest column, excluding empty columns.

The input will be an integer, representing the number of columns to be output, and an array of integers, representing the paragraph heights in lines. There is more than one way to represent the output; it could be an array (one for each column) of arrays of paragraphs, or it could be an array (one for each paragraph) of columns. (Please indicate whether your arrays are 0- or 1-based.) You may use any convenient format for (e.g. the number of columns as a command-line parameter and the array on STDIN) for I/O.

Because the paragraphs are double-spaced, there will be at least two lines in each paragraph, but if you prefer, your answer can take the double-spacing into account internally.

Within each column, paragraphs should be listed in ascending order, and the columns should be listed in ascending order of their first paragraph. Examples:

2, [2, 3, 4, 5, 6] -> [2, 3, 5], [4, 6] or [0, 0, 1, 0, 1]
3, [2, 3, 4, 5, 6] -> [2, 5], [3, 4], [6] or [0, 1, 1, 0, 2]
4, [2, 3, 4, 5, 6] -> [2, 3], [4], [5], [6] or [0, 0, 1, 2, 3]
5, [2, 3, 4, 5, 6] -> [2, 3], [4], [5], [6] or [0, 0, 1, 2, 3]


Note that in the last example the height could not be reduced by adding the extra column so in this case only four columns could be utilised.

• If it's not a requirement to use every column (as indicated by your last example), that should be called out explicitly rather than inferred. – AdmBorkBork Sep 30 '16 at 14:02
• @TimmyD "maximise the height of the shortest column, excluding empty columns" not explicit enough for you? – Neil Sep 30 '16 at 17:25
• Yeah, as I didn't understand that to mean that I could optionally choose to have empty columns if it made the output more even. Maybe "explicit" wasn't the right word in my comment, but it could be more clear. – AdmBorkBork Sep 30 '16 at 17:57

No, this challenge is not this

## Where is my error?

My compiler has broken down and now it is only showing the index of the character which the error is on.

In this challenge you will write a program to point to the given character.

## Examples

Input:

if (goat == Downgoat) {
print(Downgoat));
}

43


Output:

1 | if (goat == Downgoat) {
2 |     print(Downgoat));
|                    ^
3 | }


## Spec

TODO

• I was going to suggest giving an {x, y} pair as input, but that would make the challenge substantially easier. – ETHproductions Sep 30 '16 at 22:40
• What if there are more than ten lines? – Conor O'Brien Oct 5 '16 at 1:14

# First 100 prime numbers in Wentelx87 code-golf

Wentel consists of, at the basic level, a memory pointer and an instruction pointer. Instructions are stored loaded into memory. The execution pointer moves to the right after executing the instruction at that memory pointer.

The program is loaded into rightmost slot of memory. For example, if your program is 0010 0000 0101 0100, then the virtual machine will look like this when started:

0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 0000 0101 0100 (memory)
^                   (execution pointer)
^                                                                               (memory pointer)


Wentel documentation examples, thorough and clear explanation here.

Wentel is language that is very hard to program in. Unlike brain**k, functions and GOTOs can be implemented. It emulates real machine code/assembly much better than brainf**k.

Wentel is a simple language.

1. instructions are held in the rightmost cells, one cell = one instruction
2. execution pointer starts out on first instruction
3. execution pointer moves right
4. the same cells that hold memory hold instructions.
5. these are the opcodes:

0000 - no-op

0001 - if the current address's value is equal to the value stored by the adress defined by the next word, move the execution pointer to the address pointed to the next word after the word after the current address.

0010 - move memory pointer to address specified by next word.

0011 - deposit the current address of the execution pointer into the current memory address

0100 - increment current memory address

0101 - decrement current memory address

0110 - move memory pointer left

0111 - move memory pointer right

1. and here are the specialized opcodes for output.

1000 - output 0

1001 - output 1

That was a boiling down of Wentel. Please read the full docs. Now for the actual challenge. Output the first 100 prime numbers, separated by spaces, in Wentel.

This is , so the shortest answer in bits wins.

• If you want to encourage an answer to an existing question in a new language, the way to do it is with a bounty on the existing question. If you're worried about losing your rep because no answers will be posted, see meta.codegolf.stackexchange.com/q/5243/194 – Peter Taylor Oct 10 '16 at 8:33

# Is this Rubik's Cube Solvable?

The challenge: find out if a rubik's cube configuration is solvable.

Takes input as a multidimensional array. An example for a solved cube would be

[
[
[0,0,0],
[0,0,0],
[0,0,0]
],
[
[1,1,1],
[1,1,1],
[1,1,1]
],
[
[2,2,2],
[2,2,2],
[2,2,2]
],
[
[3,3,3],
[3,3,3],
[3,3,3]
],
[
[4,4,4],
[4,4,4],
[4,4,4]
],
[
[5,5,5],
[5,5,5],
[5,5,5]
]
]


starting on the sides, going round, then top, then bottom. This input would give an output of 1, since it is solvable (very, very solvable). A (small) net of this solved cube would therefore be:

     _
_ _|4|_
|0|1|2|3|
¯ ¯|5|¯
¯


The result of the program should be a truthy/falsey value, printed to STDOUT or similar. This is code-golf, so shortest answer in BYTES wins. Standard loopholes apply.

• What is the winning criterion? – acrolith Oct 12 '16 at 17:16
• shortest code. I'll add code-golf as a tag now. – Geno Racklin Asher Oct 12 '16 at 17:20
• I think you've got an extra 2 side in your example. – AdmBorkBork Oct 12 '16 at 17:55
• whoops. Thanks for pointing that out. I will add some test cases soon. – Geno Racklin Asher Oct 12 '16 at 17:57
• Add for people less familiar with the cube group that it has 12 = 2 * 2 * 3 orbits, 2 because you can't only exchange edges, 2 because you can't only flip an edge and 3 because you can't only turn a corner – Ton Hospel Oct 12 '16 at 22:25
• codegolf.stackexchange.com/q/10768/194 . There's no fundamental difference between solving it and testing whether it can be solved. – Peter Taylor Oct 13 '16 at 7:21
• @PeterTaylor I'd say there is a big difference. Trying to solve a cube is pointless if it's impossible to begin with. This is about spotting which cubes have been tampered with. – Geno Racklin Asher Oct 13 '16 at 9:27
• Do you have a reference implementation which uses an approach other than trying to solve it and seeing whether you get stuck? (Also, if it is possible to do it without solving, I strongly recommend trying to find a way to prohibit brute-force solving, because that can be very short). – Peter Taylor Oct 13 '16 at 10:01
• Not yet, but I'm working on it – Geno Racklin Asher Oct 13 '16 at 12:52