571
\$\begingroup\$

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

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

  • Parts of the challenge you found unclear
  • Comments addressing specific points mentioned in the proposal
  • Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

\$\endgroup\$
0

4633 Answers 4633

1
56 57
58
59 60
155
1
\$\begingroup\$

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.

\$\endgroup\$
4
  • \$\begingroup\$ I'm not even sure that this is possible. \$\endgroup\$
    – Fatalize
    Sep 28, 2016 at 12:01
  • 2
    \$\begingroup\$ Why would it not be possible? The only potential problem I see is being closed as a dupe for being a straightforward generalised quine. \$\endgroup\$ Sep 28, 2016 at 12:05
  • \$\begingroup\$ @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. \$\endgroup\$
    – Fatalize
    Sep 28, 2016 at 12:09
  • 2
    \$\begingroup\$ meta.codegolf.stackexchange.com/a/8595/194 \$\endgroup\$ Sep 28, 2016 at 13:28
1
\$\begingroup\$

Priority to the right

Your task is to regulate traffic on a crossroads. There are 4 roads coming from north, east, south and west.

The input is a string representing the upcoming traffic on each road. For example, NNNWS indicates there is a total of 5 cars: three at the north, one at the west and one at the south. The order has no importance here, NNNWS is equivalent to WNNSN.

You must output the order in which the cars should go, using the priority to the right rule: cars coming from the south must let cars coming from east go first, east gives way to north, north gives way to west and west gives way to south.

For example, with the input NNNWS, the south car should go first, then the west car, then the 3 north cars. The output should then be SWNNN.

There are some indecidable cases, for example NS or NNWSE : you should then output the string stuck.

Test cases

N => N
NW => WN
NWS => SWN
SNW => SWN
SSSSS => SSSSS
ENNNNES => NNNNEES
NS => stuck
NNWSE => stuck
\$\endgroup\$
1
\$\begingroup\$

golf.ko - Kernel module golf

A Linux-specific challenge.

Implement a Linux kernel module which printks Hello world upon loading, in some compiled language.


Source file, linker scripts and command lines, Makefile content (if any) are all counted towards the byte score.

You may expect kernel version to be 4.1 or 4.4.

The kernel is assumed to be running. It's built, not cleaned source code is assumed to reside in /usr/src/linux. In addition you may expect the system to be Debian and to have working DKMS.

\$\endgroup\$
5
  • 1
    \$\begingroup\$ Maybe can be a catalog. \$\endgroup\$
    – Vi.
    Sep 30, 2016 at 13:18
  • \$\begingroup\$ What does it mean for a kernel module to "print"? \$\endgroup\$ Sep 30, 2016 at 18:00
  • \$\begingroup\$ Issue behaviour similar to printk kernel API function in C. Output message to logs, to console, to /proc/kmsg. Shall definition what exactly is a printk be included? Obviously user is expected to call the function inside kernel, not re-implement printk. \$\endgroup\$
    – Vi.
    Oct 2, 2016 at 18:29
  • 1
    \$\begingroup\$ I see: "printks" just looks like a typo, it isn't really one. That could be clearer if you wrote "printks", and clearer still if you link to a man page or other documentation. But if you're requiring use of that library, you can pretty much rule out answers in languages other than C and maybe Rust (since what other languages will have bindings for it?), and I wouldn't be surprised if there's nothing interesting left to golf and you just get one answer. \$\endgroup\$ Oct 3, 2016 at 11:49
  • \$\begingroup\$ @PeterTaylor, Maybe just exclude printk requirement and require just some code derived from posted source code to be executed? Or just the endless loop (it should be doable in almost any language, is API-agnostic and is observable)? \$\endgroup\$
    – Vi.
    Oct 3, 2016 at 23:32
1
\$\begingroup\$

Random Quine

(something related to languages?)

You are to write N programs in N langauges (at least 2) that satify the following properties:

  1. For each program P, the program P must produce an output O that is equal to a random program Q that you wrote, including P.
  2. No two programs P and Q may be equal.

Let's say you have two programs, ABCD in language Bar and 1234 in language Baz. Then, ABCD must produce each of ABCD and 1234 with nonzero (but not necessarily equal) probability. Similarly, 1234 must output ABCD or 1234 with nonzero chance. Note that the chances do not have to be same for each program.

\$\endgroup\$
2
  • \$\begingroup\$ Higher N being winning doesn't seem to be viable on it's own as I think this could be done essentially forever. Will it be something like total length of all Ps divided by N? \$\endgroup\$ Oct 5, 2016 at 22:35
  • \$\begingroup\$ 1. On clarity: it's not clear what the requirements are for which programs each P must produce with non-zero probability. All of them? At least two different ones? ("At least one" would satisfy the stated properties, but not the explanation in the example). 2. On boringness: the programs can just be identical apart from an integer or string literal which they ignore when executing and replace at random when outputting. So a generalised quine of half of the random challenges would meet spec. \$\endgroup\$ Oct 6, 2016 at 7:28
1
\$\begingroup\$

Introduction

The challenge is to determine if two complex lines intersect.

Challenge

Given two lines made up of multiple straight line segments determine if the lines cross at any point.

Input can be in the format of you choice that takes a series of [x,y] coordinates. All coordinates will be integers (positive or negative)

Output will be truthy if the lines cross and falsey if they don't cross.

There will be no coincidental points and no segment of one line will terminate at a point touching the other line (there will be a clean cross of line segments if the case is truthy).

This is code golf so shortest answer wins

Example Input and Output

For the examples formats are given as

Line 1: [[X1,Y1],[X2,Y2]...,[Xn,Yn]] Line 2: [[X1,Y1],[X2,Y2]...,[Xn,Yn]]

Examples

Line 1: [[0,0],[1,1]] Line 2: [[0,1],[1,0]] = TRUE

Line 1: [[2,2],[1,0],[0,2]] Line 2: [[0,1],[1,1]] = TRUE

Line 1: [[1,3],[2,9],[3,6],[4,7],[5,4],[6,1]] Line 2: [[2,6],[3,5],[5,2]] = FALSE

Line 1: [[0,6],[3,8],[5,5],[8,5]] Line 2: [[0,4],[3,7],[5,4],[7,6]] = TRUE

Line 1: [[2,2],[3,2]] Line 2: [[1,1],[10,4]] = FALSE

enter image description here

Please let me know your thoughts, first puzzle.

\$\endgroup\$
3
  • \$\begingroup\$ What about the case where one of the line segments "touches" another. That is: one of the end points of a line is on the other line. Would that be considered "crossing" or not? \$\endgroup\$
    – DarthRubik
    Oct 6, 2016 at 23:49
  • \$\begingroup\$ @DarthRubik tried to clarify, don't need to handle that case. \$\endgroup\$
    – gtwebb
    Oct 6, 2016 at 23:55
  • \$\begingroup\$ All of the test cases have x increasing strictly monotonically. Is this guaranteed, or could line segments be vertical or even loop back? If you don't guarantee that input will avoid those situations, please add test cases to cover them. \$\endgroup\$ Oct 9, 2016 at 16:11
1
\$\begingroup\$

Raytracing/Raycasting

Here is a 256*256 heightmap. Your challenge is to render it, in minecraft-style blocks, using some form of raytracing.

enter image description here

Fundamental Definitions And Clarifications

These are all straightforward and fairly obvious but I'm being explicit so that what follows is (ideally) unambiguous.

  • Let each pixel represent 1x1 metre, for ease of thought.
  • This image is a top-down view. The bottom-left pixel of the image in screen space is at [0,0,0] in world space. The bottom-right pixel of the image in screen space is at [255,0,0] (i.e. the next full tile to the right would be anchored at [256,0,0]). The Z-axis increases away from us in world space so the top-left pixel is at [0,0,255] and the top-right-pixel is at [255,0,255].
  • As you are looking down to the floor at the moment, you have positive height and the vector from your eye to the image points in the direction of [0,-1,0], so the camera which corresponds to the above image has a world-space coordinate of something like [128,300,128].
  • It shouldn't really matter, but let's take the red channel as holding the height. A red channel value of foo puts that pixel at y=foo. The tallest possible pixel would have world coordinate [x,255,z] with 0<=x,z<256.

Aesthetic Definitions

  • Each pixel effectively represents a tower some number of 1x1x1 solid cubes. The edges of these blocks should be rendered sharply at 90-degree angles. If you were to convert this scene to triangles, each normal would be along one of the major axes. You can think of blocks having end-caps on their top (which is the floor, to us), and walls are extruded between neighbouring blocks as required. There are no holes in the rendered surface. You can assume all renderings will be from above (extra implied geometry below the floor doesn't matter).
  • As well as the heightmap, the world contains one camera and one light source. The light casts hard shadows, so every rendered pixel will require two ray casts. Light falloff is inverse-square. You may optionally gamma-correct the result.
  • Pixels on a surface which receive no light should be black. Pixels of rays which do not hit any surface should be magenta: rgb=(255,0,255).

Input Parameters

  • The camera is defined by position P=[px,py,pz], a T=[tx,ty,tz] target point, and a field of view FOV. It renders WIDTH x HEIGHT images such that the target point appears in the centre.
  • The camera is orientated such that it yaws, then pitches, but does not roll.
  • The light is at position L=[lx,ly,lz] and casts light uniformly in all directions.
  • You solution must be posted with reference image rendered with P=[80,256,0], T=[128,50,200], L=[256,300,128], WIDTH=400, HEIGHT=300 and FOV=45 degrees.
  • (As reference images emerge I might tweak these parameters.)

Free Parameters

  • The light can be any colour and brightness you like but the colour and brightness must be inputs to the program.
  • Likewise, the colour/material of the surface may be anything you like (except magenta, which is for revealing holes) but these colour/material parameters must be an adjustable input to the program.
  • Use any lighting/shader model you like.
  • Use fog or other effects if you like. Different submissions are likely to vary considerably in size, so there's room to play a bit.

Criteria

  • You must post code which can be run as-is, with the specified reference parameters and all your free parameters included.
  • You can take the heightmap image as hardcoded in a representation of your choice and this does not count towards your golf score. You must post the code which converts an image to your preferred format. This script should either run using common Linux command-line tools, or over an online service. This script should not assume that heightmaps are square.
  • The output of raw pixel data can be in any format you like (e.g. [[r,g,b],...] BUT you must provide a second script, not counted towards your golf score, which turns your program's raw output into some standard image format such as PNG. This script should either run using common Linux command-line tools, or over an online service.
  • You must post the final image produced by this method, as well as the code which produces the output which produces the image.

In a nutshell, the above specifies that your output is reproducible, with different parameters and heightmap images as desired.

The winner will be chosen a few weeks from now, as the shortest code which conforms to the above aesthetic specifications (e.g. shadows, no holes, etc) and which gives end-to-end reproducible results.

\$\endgroup\$
4
  • \$\begingroup\$ Maybe include a sample output? \$\endgroup\$
    – Steven H.
    Oct 7, 2016 at 18:10
  • \$\begingroup\$ My own attempt at this is part of a larger, more complex project, it'll be a while :-) In the meantime I was curious if others would find a simplified version of the problem a bit more fun. \$\endgroup\$
    – spraff
    Oct 7, 2016 at 19:42
  • \$\begingroup\$ Must run, so will expand on this later, if not within 48 hours then ping me. There are some subtleties with respect to offsets (are blocks centred?) The stuff about fog etc is wasted space, because in code-golf no-one will spend bytes on it, so remove it to KISS. I strongly advise before posting to get a test output which two independent programs agree on. \$\endgroup\$ Oct 8, 2016 at 8:07
  • \$\begingroup\$ 1. The subtlety I promised to expand on: does "The bottom-left pixel of the image in screen space is at [0,0,0] in world space" mean that the pixel corresponds to the voxel whose coordinates range from (0,0,0) to (1,1,1) or the voxel whose coordinates range from (-0.5, -0.5, -0.5) to (0.5, 0.5, 0.5)? 2. Also, what does "The camera is orientated such that it yaws, then pitches, but does not roll" mean? Perhaps it could be better expressed by giving the initial up, forward, right vectors and then saying around which axes it rotates. \$\endgroup\$ Oct 9, 2016 at 16:09
1
\$\begingroup\$

First 100 prime numbers in Wentelx87

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)

(from README)


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.

\$\endgroup\$
1
  • 1
    \$\begingroup\$ 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 \$\endgroup\$ Oct 10, 2016 at 8:33
1
\$\begingroup\$

A simple but fun code golf challenge!

Given positive integer n

create a 2 dimensional matrix where each location is filled with it's xy index (starting from the top left).

For example:

Your grid should look like: input: 2

00 10
01 11

input: 3

00 10 20
01 11 21
02 12 22

Once the grid is created, randomly fill each index. This can be with an 'x' or any other way to denote a spot has been filled

A complete simulation looks like:

input: 3

x x x
x x x
x x x

O O O
O O O
O O O

You can use whatever character you want to fill in each location.

Extra points if you use a GUI and use black squares to fill it in

You should only fill a spot in once so the number of times you fill should be n^2. (So no randomly filling spots until they are all filled you have to check!)

You can refresh the grid however you want. i.e print the grid, make a new line, print again... You can use a timer. However you want to do it to illustrate each step. You only need to refresh when you are filling not when you are populating the grid.

An example simulation looks like this:

input: 2

00 10
01 11

randomed 01

00 10
XX 11

randomed 11

00 10
XX XX

randomed 11
re-roll
randomed 01
re-roll
randomed 00

XX 10
XX XX

randomed 10

XX XX
XX XX

Complete

Do not display your randomed numbers, the output should tell me which were randomed.

Have fun!

\$\endgroup\$
0
1
\$\begingroup\$

Just like magic


Nowadays, the word "abracadabra" is used mostly in connection with magic tricks. The original purpose of the word had more to do with superstition, and some doctors used it to make lethal diseases go away by writing it in a triangle1, like so:

A B R A C A D A B R A
 A B R A C A D A B R
  A B R A C A D A B
   A B R A C A D A
    A B R A C A D
     A B R A C A
      A B R A C
       A B R A
        A B R
         A B
          A

Your task is to write a program or function that outputs/returns the exact text shown above in as few bytes as possible. The output may contain trailing spaces on each line and/or trailing newlines. This is , so the shortest code in bytes wins.

1. https://en.wikipedia.org/wiki/Abracadabra


Sandbox questions

  • Is it too simple?
  • Is it a duplicate?
  • Any better name ideas?
\$\endgroup\$
4
  • \$\begingroup\$ "It's magic, you know! Never believe it's not so!" \$\endgroup\$ Oct 11, 2016 at 20:32
  • \$\begingroup\$ @VTCAKAVSMoACE Haha :) though I'm not sure how many people would get the reference. I had to google the lyrics, but the song sounds very familiar. I wonder where I've heard it before... \$\endgroup\$ Oct 11, 2016 at 20:39
  • \$\begingroup\$ Well, it's the same formatting than Number Triangles, but the task is clearly different. I suppose you could also call it "A Kind of Magic", although the Queen/Highlander reference might be a bit far-fetched. \$\endgroup\$
    – Arnauld
    Oct 11, 2016 at 23:04
  • \$\begingroup\$ The closest I can think of as a dupe is codegolf.stackexchange.com/q/65300/8478, but it seems likely that it's shorter to generate each line from the previous instead of generating a string of all prefixes first and the laying it out in a triangle. \$\endgroup\$ Oct 12, 2016 at 12:38
1
\$\begingroup\$

Ungolf batch

This question wants you to golf batch programms. In Batch you can use

set x=averylongbatchcommand
%x% arg1

which expands to

set x=averylongbatchcommand
averylongbatchcommand arg1

Your task is it to expand these statements.
As you can also use set for arithmetic purposes like this:

set x = 0
set /a x= %x%+1

you should ignore the statements where the pattern with set /a is applied.
There will never be something like

set s=SET
%s% s=%s% a

where the variable is assigned using itself as command. But you have to handle things like

b:
set a =echo
%a% Hello World!
set a=goto
%a% b

Scoring

This is so the answer with the fewest bytes wins.

Testcases

set s=set
%s% e=echo
%e% I will have to use this exact thing very often because
%e% it absolutely wouldn't be shorter if i just left out these set statements

Expands to:

set s=set
set e=echo
echo I will have to use this exact thing very often because
echo it absolutely wouldn't be shorter if i just left out these set statements

set s=set
%s% i=0
set g=goto
:a
if %i%==15 (
%g% e
)
%s% /a i=%i%+1
%g% a
:e

Expands to:

set s=set
set i=0
:a
if %i%==15(
set e
)
set /a i=%i%+1
goto a
e:

set s=set
%s% s=%s% a=

Mustn't be supported.

\$\endgroup\$
2
  • \$\begingroup\$ Too bad the question mentioned has no answers... \$\endgroup\$ Oct 18, 2016 at 0:44
  • \$\begingroup\$ I will probably post It tomorrow, if there isn't any critic. \$\endgroup\$ Oct 18, 2016 at 12:46
1
\$\begingroup\$

Convert Birkana to Hexademical

Introduction

Birkana is a not-very-well-known notation for hexadecimal using rune-like symbols. The general structure of a Birkana rune is like this:

|\     <-- 0x1
|/     <-- 0x2
|\     <-- 0x4
|/     <-- 0x8

The slash or backslash is present if its base number (0x1, 0x2, 0x4, or 0x8) is present in the number, or not otherwise. The pipe is always at the left-hand side.

For example, here's the Birkana rune for 0xD (= 0x1 + 0x4 + 0x8):

|\
|
|\
|/

Challenge

Given a Birkana rune as input, write a program or function to output the corresponding hexadecimal digit.

You may choose to output either lowercase (a-f) or uppercase (A-F) hex digits, but they cannot be mixed.

You only need to support the 16 hexadecimal digits and their corresponding Birkana runes.

Test cases

Input
Output

|
|
|
|
0

|\
|
|
|
1

|
|/
|
|
2

|\
|/
|
|
3

|
|
|\
|
4

|\
|
|\
|
5

|
|/
|\
|
6

|\
|/
|\
|
7

|
|
|
|/
8

|\
|
|
|/
9

|
|/
|
|/
A

|\
|/
|
|/
B

|
|
|\
|/
C

|\
|
|\
|/
D

|
|/
|\
|/
E

|\
|/
|\
|/
F

Scoring

This is , so the shortest answer (in bytes) wins.

\$\endgroup\$
1
  • \$\begingroup\$ Is this just binary displayed vertically using space/nothing for zero and a slash for a one? I guess the fact that the slashes alternate could just be ignored, treating each position as either empty or full, which would still give the correct output? If so, is it acceptable to output a hex digit for invalid inputs? This is likely to make a difference to the approaches used. \$\endgroup\$ Oct 18, 2016 at 12:03
1
\$\begingroup\$

Find the least squares regression line

Background

I'm taking AP stats now, so I figured I'd bring the joy to you all here.

The form of an LSRL (least squares regression line) is ŷ = a + bx.

Input

Your job is to find the least squares regression line for two data sets (lists), X and Y. X and Y will be the same size with at least 2 elements. They will contain positive or negative floats. Input can be taken in any reasonable format.

Output

The values a and b in the least squares regression line (LSRL) for the data in X and Y, where a is the y-intercept and b is the slope of the LSRL. This page describes a way to calculate this line.

This is , so shortest code in bytes wins!

Also, built-ins are allowed!

Examples

[1.0, 2.0, 3.0, 4.0] [12.0, 15.0, 16.0, 17.0] -> A: 11.0 B: 1.6
[1.5, 1.5, 51.0, -15.0] [2.0, 1109.0, 0.003, 2.0] -> A: 314.92 B: -3.7609
[1.0, 2.0] [1.0, 2.0] -> A: 0.0 B: 1.0
[-15.0, -13.0, -163.0, -12.25, -14.41, 100000.0, -630.0, -135.0] [-142531.0, -12.0, 153.0, -135.0, 135.0, 16.0, 21.0, 0.0] -> A: -20285.0 B: 0.20121
[3.0, 5.0, 7.0, 9.0, 11.0, 13.0] [2.0, 4.0, 6.0, 8.0, 10.0, 12.0] -> A: -1.0 B: 1.0
\$\endgroup\$
5
  • \$\begingroup\$ 1. Use the full name in the title, because the title will be shown in contexts where the body isn't. 2. What kind of numbers will X and Y contain? The test cases use signed integers, but can answers assume that all inputs will be integers, or that all inputs will be floating point numbers? 3. In some contexts, a quadratic can validly be described as a least squares regression line. It would be better to move the definition which makes it clear that it's a linear polynomial to the introduction, before the section on input, rather than having it in the section on output. \$\endgroup\$ Oct 22, 2016 at 20:55
  • \$\begingroup\$ 4. There's more than one way to calculate the gradient, and the method described is not the best one. I would suggest removing that section entirely and having a link to en.wikipedia.org/wiki/Simple_linear_regression in the introduction. \$\endgroup\$ Oct 22, 2016 at 20:56
  • \$\begingroup\$ @PeterTaylor, I have edited the question. Is it better now? \$\endgroup\$
    – Daniel
    Oct 22, 2016 at 21:26
  • \$\begingroup\$ Every math language has a builtin for this so it's just solve(x,y). Even without the built-in linear solver, this is just the pseudoinverse of (1,x) multiplied with y. \$\endgroup\$
    – Angs
    Oct 23, 2016 at 6:04
  • \$\begingroup\$ I disagree with Peter - for the sake of self-containedness, you should include at least one method of computing the LSRL (and keep the link in case people want to see more methods). \$\endgroup\$
    – user45941
    Oct 24, 2016 at 6:50
1
\$\begingroup\$

2D Poor Man's Plotting!



Introduction

Surely you've also come across the problem where you have a multi-dimensional function at hand and want to visualize it (it's just such an everyday problem!). So we need a (programmatic) solution to this. A memorable solution, thus obviously the shortest solution is best!

Specification

Input

Your (primary) input will be a function that maps two floats onto another float.

Additionally there are six other parameters (floats), which you may take explicitely or hard-code:

  • StartingValueX: 0
  • StartingValueY: 0
  • EndingValueX: 10
  • EndingValueY: 10
  • StepSizeX: 1
  • StepSizeY: 1

You may take these parameters using your preferred method of input, but please document it (especially how the function should be passed).

Output

The output is a formatted string or a printed output (whatever pleases you).

What to do?

The introduction already hinted it:
Given a function that takes two floats as inputs, iterate it two-dimensionally and print the resulting values. So the top left entry is the result of the evaluation at (StartValueX,StartValueY) and the bottom right entry is the evaluation of (EndValueX,EndValueY) and then you form basically a table from this by incrementing the StartValue by the respective StepSize for each iteration.

Formatting guidelines:
Between each line may be one (or more) empty lines (eg end your lines with \n\n in C).
There must be at least one white space between every output number.
All numbers with the same x-coordinate must be aligned respectively to their start.

Potential Corner Cases

You may always assume a certain function prototype is used.
If EndValue-StartValue is not an exact multiple of StepSize (which may happen because we're dealing with floats here) then you shall compute for all StartValue + k * StepSize smaller than EndValue as well as for EndValue.
You may always assume the computation results (of the function) are actually representable in your language.
You may not assume that the function is a simple mathematical function (e.g. any valid function adhering to the above conditions in your language must work).
Trailing newlines and white spaces are allowed.

Who wins?

This is code-golf so the shortest answer in bytes wins!
Standard rules apply of course.

Test-cases

Default parameters, f(x,y)=x+y
Output:

0  1  2  3  4  5  6  7  8  9  10
1  2  3  4  5  6  7  8  9  10 11
2  3  4  5  6  7  8  9  10 11 12
3  4  5  6  7  8  9  10 11 12 13
4  5  6  7  8  9  10 11 12 13 14
5  6  7  8  9  10 11 12 13 14 15
6  7  8  9  10 11 12 13 14 15 16
7  8  9  10 11 12 13 14 15 16 17
8  9  10 11 12 13 14 15 16 17 18
9  10 11 12 13 14 15 16 17 18 19
10 11 12 13 14 15 16 17 18 19 20
\$\endgroup\$
1
\$\begingroup\$

[Lang1] vs [Lang2] ... vs [LangN]: Battle of the golfers!

and other tags for the challenge questions, which may be a lot.

Note: I haven't figured out all the kinks out yet, all I have is a general idea that, with your help, can be put properly into an awesome challenge (I hope). The parts where my ideas are not solid yet have Notes attached to them that must be read.

Team

In the midst of the nation of SE, there lies a golf field for the community of golfers. These golfers play day and night using specialised clubs (languages) to complete difficult and challenging holes (challenges). Now it is time to see the best of these golf clubs in the game!

Note 1: First of all, this challenge is going to be language-specific. I haven't decided the languages yet, but right now I'm thinking around the lines of Java, C, C++, C# since these languages are very well known, unlike the other esoteric languages.

You, the golfer, are to choose one golf club out from these [Lang1], [Lang2], ..., [LangN]. You will team up with other players using the same golf club as you.

Note 2: Now there is supposed to be a table where the players can edit into this challenge (once I post it) to join a team. After ~1 week from the beginning of the sign-up, people will start competing in the challenge.

This will be a sort of golf relay, where every player must only complete 1 hole, no more, no less. But of course, each player may help teammates to complete the holes using the minimum number of shots (bytes) as possible. All golfers, of every team, will be playing using the same playing field, in this case UTF-8.

The Challenge

There will be a list of challenges [see Note 3] to be completed by the team. Each team member must complete 1 challenge only. After a fixed amount of time (see Note 3), all team members must have complete their assigned challenges (see Note 4). I will sum of all the bytes used by each team to figure out the winning team (see Note 5)!

Note 3: Either I will provide all the challenges, or each team member may give 1 challenge to the challenge pool. Challenges can range from anything like quines and "Hello, World" challenges, to more complicated ones, like solving advanced mathematical (pardon me) mumbo jumbo and outputting complex sequences. Every team completes all of these challenges (see Note 4).
The time that I have decided, so far, is to give the entire team 3 weeks (subject to change) to complete their challenges.

Note 4: Each team member complete 1 challenge. However, if the team sizes are different, the team with the greatest number of members will have to complete all of the challenges. The other teams only have to complete as many challenges as members, so that there will be one for every member.

Note 5: The scoring will be the number of bytes used by each team, summed up, and then divided by the number of challenges completed.

Answering

Here is the format to each answer:

#Language, challenge-number, byte-count in UTF-8

for example:

#Java, #34, <s>463</s> <s>444</s>  <s>442</s> bytes

Summary

To sum it up, here is the process that this challenge goes through:

  1. People who want to play must choose one team to be on, if they want to play.
  2. After registration is over, the games begin: each player is to choose only one challenge and give a golfed answer. (Other players of the same team are allowed to help teammates)
  3. After some time, when all the challenges are attempted (one for every person, if people haven't answered in this time, they won't be counted towards the challenge), I will calculate the score of each team (using the total bytes used).
  4. Leaderboard is announced and the winning team walks away with all the glory!

Comment any ways this challenge can be improved. My general idea is to implement a team game, instead of the standard free-for-all.

\$\endgroup\$
1
1
\$\begingroup\$

King of the Hill: Moon Rockets

This is a challenge where you code bots to compete in an arena. In this case, you code a rocket flying over the Moon. Your goal is to shoot down enemy rockets, while not running out of fuel and crashing into the Moon.

Environment

Unlike many KOTH challenges the playing field is continuous, rather than discrete. You are provided with variables for your position, velocity, and the direction you are facing. Each turn, you are given a list of all the rockets you can "see" (all rockets less than 10 units away). You return a turning speed, thrust and whether you want to fire missiles.

Arena

The arena wraps left-right. There is a floor; if you crash into it going faster than 4 m/s, you will explode. There is no ceiling, but you do have a limit of 10 fuel units. This can be refueled by landing on the floor going less than 4 m/s.

Missiles

Every turn, you have the option to fire missiles. Missiles go in the direction you are pointing, at a constant velocity 5 m/s faster than you were when you fired. If they come within a 1m radius of another rocket, they explode and destroy it.

Gravity

Gravity is a constant force of 1 downward. With a max thrust of 2, you can accelerate at an equal rate in the opposite direction.

Pastebin for current controller code: http://pastebin.com/FNyjrJfr
No tournament code is in place yet.

\$\endgroup\$
10
  • \$\begingroup\$ Possibly relevant: Spacewar KotH \$\endgroup\$ Oct 25, 2016 at 20:11
  • \$\begingroup\$ The controller seems to set the step size at 0.5s. Does that give enough time to take evasive action at all, given the missile speed and sight range? (Even discounting step size, with max thrust of 2, it seems like it's going to be hard to outmaneuver something going possibly several times faster) \$\endgroup\$
    – Geobits
    Oct 25, 2016 at 20:11
  • \$\begingroup\$ Additionally related to step size, how are collisions handled? If I'm a meter away from you and fire a missile that goes 7m/s, can it miss by overshooting in that half second? \$\endgroup\$
    – Geobits
    Oct 25, 2016 at 20:14
  • \$\begingroup\$ Can spaceships collide with each other, or only the surface? \$\endgroup\$
    – Geobits
    Oct 25, 2016 at 20:15
  • \$\begingroup\$ 1. Continuous presumably means floats, which means possible disagreements over the results (because e.g. Java doesn't strictly apply the IEEE-754 spec unless you tell it to). 2. The spec should say at the very least what information is available to the bots. Does the "list of all the rockets you can "see"" include velocity, angular velocity, etc. or just position? \$\endgroup\$ Oct 25, 2016 at 20:24
  • \$\begingroup\$ I assume one win condition is "last rocket flying", but what about stalemates? Is there a "last turn", since it seems like a couple pacifists could land/refuel forever? \$\endgroup\$
    – Geobits
    Oct 25, 2016 at 20:27
  • \$\begingroup\$ @Geobits - the collisions are handled point-by-point, so yes, you could miss someone right in front of you if you have a high closing speed. I think evasion is possible as long as you have at least 1 step of warning. \$\endgroup\$
    – Skyler
    Oct 26, 2016 at 13:10
  • \$\begingroup\$ @Geobits Spaceships can't collide in the current code. If they could, what should define a "collision"? Currently they are modeled as point objects. \$\endgroup\$
    – Skyler
    Oct 26, 2016 at 13:11
  • \$\begingroup\$ @PeterTaylor they can access velocity etc. as well as position. I think this might be required as if a rocket is moving fast you need to lead it with the missile. \$\endgroup\$
    – Skyler
    Oct 26, 2016 at 13:12
  • \$\begingroup\$ @Geobits I could add a condition that limits the total turns. Does 50 turns seem reasonable? \$\endgroup\$
    – Skyler
    Oct 26, 2016 at 13:13
1
\$\begingroup\$

C Compiler

Implement a basic C Compiler.

You do not need to implement the libraries. Compiler would output an object file containing a function, that would be linked with some libraries using GNU binutils ld and run.

No function calls, unions, structs, casts will be used in the test cases.

Test case:

int test(int i, int j) {
  int x[10][20];
  int s = i + j;
  i = 0;
  j = 0;
  for(i = 0; i < 10; i++)
    while (j < 20)
    {
      j += 1;
      x[i][j] = i * j;
    }
  for(i = 0; i < 10; i++)
    while (j < 20) {
      s += x[i][j];
    }
  return s;
}

\$\endgroup\$
1
  • 2
    \$\begingroup\$ What does need to be implemented? A question should ideally be self-contained, but if there's too much information to fit in the post then it should contain links to the relevant specifications. \$\endgroup\$ Oct 26, 2016 at 10:08
1
\$\begingroup\$

HamSort a list of strings

Given a list of strings, sort them in a manner such that the Hamming distance between each is minimal.

The Hamming distance between two strings of equal length is the number of positions where the corresponding characters do not match. For example, the Hamming distance between apple and ample is 1 since only the second characters of each do not match.

apple
ample
 *

Rules

  • This is so the shortest code wins.
  • Each string in the input list will have the same length and will consist of only the letters in the English alphabet. You may assume all to be either uppercase or lowercase.
  • If there are multiple possible solutions, you may output any number of them.

Test Cases

<to be created>
\$\endgroup\$
5
  • 2
    \$\begingroup\$ The Hamming between consecutive pairs? If so, what is to be minimized? The sum of the Hamming distances? Their maximum? \$\endgroup\$
    – xnor
    Oct 26, 2016 at 7:32
  • \$\begingroup\$ What is (for this challenge) the hamming distance of strings without equal length? Or will the list contain only strings of the same length? \$\endgroup\$
    – Laikoni
    Oct 26, 2016 at 8:06
  • \$\begingroup\$ @xnor It's still a work-in-progress. I'd like to have the problem be minimizing the Hamming distance between the consecutive pairs, but that problem might be hard enough that the only golfy solution would be generating all permutations and testing each pair. Then a length n input would have a length n-1 Hamming distance array where each value is minimal. If you have better ideas that could still capture the spirit of this, feel free to suggest them. \$\endgroup\$
    – miles
    Oct 26, 2016 at 8:33
  • \$\begingroup\$ @Laikoni Yes, Hamming distance is only defined between strings with equal length and one of the rules was that the input array would only contain strings with equal length. \$\endgroup\$
    – miles
    Oct 26, 2016 at 8:34
  • \$\begingroup\$ I think it's NP hard to find the path that minimizes total Hamming distance by reduction to Ham-Path. So, I wouldn't expect anything better than brute force there. \$\endgroup\$
    – xnor
    Oct 26, 2016 at 9:00
1
\$\begingroup\$

How fast (slow) is your language?

This is a question both to test your coding skills but also to speed benchmark your favorite language. The code snippet will make a table of the fastest code per language. It is related to previous [challenge]1 so you may find some of the code there a useful starting point.

The challenge is to write the fastest code possible for computing the permanent of a matrix whose entries are floating point in the range -1 to 1.

The permanent of an n-by-n matrix A = (ai,j) is defined as

enter image description here

Here S_n represents the set of all permutations of [1, n].

As an example (from the wiki):

enter image description here

In this question matrices are all square and will only have the floating point values in the range -1 to 1 (excluding both ends). I will construct all tests in such a way that the permanent is also in the range -1 to 1.

Examples

Input:

[[-0.34389946 -0.811193  ]
 [ 0.62778788 -0.09918764]]

Permanent:

-0.47514655471

Input:

[[-0.34389946 -0.811193  ]
[ 0.4783581  -0.56636227]]

Permanent:

-0.19326906099

The task

You should write code that, given an n by n matrix, outputs its permanent.

As the output will never be bigger than 1 in absolute value you do not have to worry about overflow. However you do have to worry about numerical accuracy. All answers should be correct up to 8 decimal places.

Languages and libraries

You can use any available language and libraries you like but no pre-existing function to compute the permanent.

More to be added..Work in progress

\$\endgroup\$
4
  • \$\begingroup\$ "All answers should be correct up to 8 decimal places." Are you sure this is possible? I suspect that finding the permanent has similar problems of ill-conditioning to finding the determinant. \$\endgroup\$ Oct 28, 2016 at 11:37
  • \$\begingroup\$ So this is your posted permanent challenge but with floats? I don't see what that's so different as to warrant another challenge. \$\endgroup\$
    – xnor
    Oct 29, 2016 at 6:12
  • \$\begingroup\$ @xnor The only differences are a) it avoids all the big int stuff that turned out to be crucial in the last challenge and b) it will have a code snippet and will be designed to encourage answers in lots of languages. Not just fast ones. The idea is to show how slow (fast) your language is and it can serve as a fun sort of language competition/benchmark. \$\endgroup\$
    – user9206
    Oct 29, 2016 at 7:07
  • \$\begingroup\$ @PeterTaylor That's a very interesting point. I am not sure of the answer but I was going to choose random orthogonal matrices (I need to change and add examples) so maybe ill-conditioning will be very rare? \$\endgroup\$
    – user9206
    Oct 29, 2016 at 7:08
1
\$\begingroup\$

Directional Brainf*ck Compiler/Interpreter

Challenge: Write a Brainf*ck compiler with 4 extra commands.

L Set the direction to go left
R Set the direction to go right
D Set the direction to go down
U Set the direction to go up

The original commands (altered):

+ Increment the cell one
- Decrement the cell one
[ Start a loop, if the cell is 0 then go to the next ]
] end a loop if the current cell is 0. Else go back to the last [ read and continue from there (in the direction you were going last time it was read.
. output the byte at the data pointer.
, accept one byte of input, storing its value in the byte at the data pointer.
> point to the cell to the right
< point to the cell to the left

Compiler/Interpreter

In this case the compiler must either convert the code to another language or be an interpreter and run the code.

This is basically a directional version of brainf*ck. Directions should work the same way they do in ><>.

The pointer should start at the tape's beginning. It must be infinite in the right direction. Left infinite is optional (if you add it -10 to the score). Upon end of code output (in any reasonable form) the current values on all the stacks. If a ] is hit before a [ output a warning (with a message of your choosing). If a , is met at the end of the code you can do with it as you please. The program will terminate at the end of the file.

Standard loopholes apply.

\$\endgroup\$
14
  • 1
    \$\begingroup\$ So, what does ] do \$\endgroup\$
    – feersum
    Oct 23, 2016 at 19:05
  • \$\begingroup\$ Taken from Wikipedia: if the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching [ command. @feersum \$\endgroup\$
    – XiKuuKy
    Oct 24, 2016 at 0:51
  • 1
    \$\begingroup\$ You don't need to tell me what it does in brainfuck. I'm asking you, what does it do in this language you're defining here? \$\endgroup\$
    – feersum
    Oct 24, 2016 at 1:02
  • \$\begingroup\$ @feersum Oh okay. If the byte at the data pointer isn't 0 then instead of going to the next command. Go back to the last [ found. Should I add that to the challenge description? \$\endgroup\$
    – XiKuuKy
    Oct 24, 2016 at 1:39
  • \$\begingroup\$ That description doesn't accord with the normal interpretation, which goes to a matching bracket, rather than the last one found. And it still doesn't clarify how it will interact with the two-dimensional aspect. In particular, what direction will the instruction pointer travel after jumping to a [? \$\endgroup\$
    – feersum
    Oct 24, 2016 at 2:01
  • 1
    \$\begingroup\$ @feersum it should go in the same direction it was going last time it was parsed I guess. I thought the last [ parsed would be better since I can't imagine matching brackets in 2D language. \$\endgroup\$
    – XiKuuKy
    Oct 24, 2016 at 2:06
  • \$\begingroup\$ You need to specify the behavior in the challenge specification. Personally I don't see an issue with jumping back to the command after the last [ encountered, continuing in the same direction. 1D programs in this extension that didn't use any of LRDU would be compatible with regular brainfuck with that behavior (assuming no mismatched braces). \$\endgroup\$
    – user45941
    Oct 24, 2016 at 6:47
  • \$\begingroup\$ Also, what does [ do if the cell is 0.... \$\endgroup\$
    – feersum
    Oct 24, 2016 at 19:03
  • \$\begingroup\$ @feersum Jump to the next ] in the current direction, presumably. That needs to be specified too, though. \$\endgroup\$
    – user45941
    Oct 24, 2016 at 21:09
  • \$\begingroup\$ @trichoplax Done. \$\endgroup\$
    – XiKuuKy
    Oct 25, 2016 at 3:43
  • \$\begingroup\$ Since tags can't be added to an answer, you can use [tag:code-golf] to show the tags you are going to use, so it won't be necessary in the title. \$\endgroup\$ Oct 25, 2016 at 9:17
  • \$\begingroup\$ If it's going to be a compiler/interpreter, it may attract more competitors if that is included in the title. \$\endgroup\$ Oct 25, 2016 at 9:18
  • \$\begingroup\$ Is this ready to post? \$\endgroup\$
    – XiKuuKy
    Oct 28, 2016 at 14:36
  • 1
    \$\begingroup\$ It's missing a lot of info. (1) The position and direction of instrucitons pointer at the beginning. (2) What happens upon reaching an edge of teh code. (3) What happens if ] is hit before any [. (4) The usual BF-specific stuff: (a) behavior of , on EOF (b) Integer range of cells (c) whether tape should be infinite in one direction, both, or something else. (5) How does the program terminate, if at all. \$\endgroup\$
    – feersum
    Oct 29, 2016 at 2:52
1
\$\begingroup\$

Modular Reverse Recursion Sequence

Given any number n > 0, let r represent the reverse of the number n. Iterate until the final result is zero, passing the result of each iteration back into the function using recursion or a methodology of your choice by performing the below operation:

  • If r > n for that iteration the result is r % n.
  • If n > r for that iteration the result is n % r.
  • If n % r = 0 or r % n = 0, you terminate iteration.

Take the intermediate result of each execution and store them in an array for the final answer.

Lets walk through an example where n=32452345.

54325423 % 32452345 = 21873078 # r > n, uses r % n
87037812 % 21873078 = 21418578 # r > n, uses r % n
87581412 % 21418578 = 1907100  # r > n, uses r % n
1907100 % 17091 = 9999         # n > r, uses n % r
9999 % 9999 = 0                # r % n = n % r = 0, terminated

Result: [21873078, 21418578, 1907100, 9999]     

Another example n=12345678:

87654321 % 12345678 = 1234575 # r > n, uses r % n
5754321 % 1234575 = 816021    # r > n, uses r % n
816021 % 120618 = 92313       # n > r, uses n % r
92313 % 31329 = 29655         # n > r, uses n % r
55692 % 29655 = 26037         # r > n, uses r % n
73062 % 26037 = 20988         # r > n, uses r % n
88902 % 20988 = 4950          # r > n, uses r % n
4950 % 594 = 198              # n > r, uses n % r
891 % 198 = 99                # r > n, uses r % n
99 % 99 = 0                   # r % n = n % r = 0, terminated

Result: [1234575, 816021, 92313, 29655, 26037, 20988, 4950, 198, 99]

A final example n=11000:

11000 % 11 = 0 # n % r = 0, terminated

Result: []
\$\endgroup\$
2
  • 1
    \$\begingroup\$ If you have to include 0 as the final element, it might be better to say "if n = 0, terminate", since terminating when n=r doesn't really include 0, because the final modulus (e.g. 9999%9999) was never done. \$\endgroup\$
    – Geobits
    Nov 1, 2016 at 18:22
  • \$\begingroup\$ @Geobits Edited to remove 0 from the list of final results, nice catch. That was the only part I did manually. \$\endgroup\$ Nov 1, 2016 at 18:33
1
\$\begingroup\$

Simplified maze-solver

A spin-off from this question Textual maze solver

Write a program, that will take an bunch of 0's and 1's as it's input (see below), and a half-solved maze as it's output. The program should take 1's as walls and 0's as corridors. The output should should show 99's as walls and a number as the distance from the start of the maze. The maze should have no real entrance/exit; instead, the entrance is the square in the 2nd column of the 2nd row.

Examples (allowed cases):

Input               Output

1 1 1 1 1 1         99 99 99 99 99 99
1 0 0 1 0 1         99 00 01 99 05 99
1 1 0 0 0 1   -->   99 99 02 03 04 99
1 0 1 1 0 1         99 10 99 99 05 99
1 0 0 0 0 1         99 09 08 07 06 99
1 1 1 1 1 1         99 99 99 99 99 99 

{{1, 1, 1, 1, 1, 1, 1, 1, 1},         99 99 99 99 99 99 99 99 99
 {1, 0, 0, 0, 1, 0, 0, 0, 1},         99 0  1  2  99 16 17 18 99
 {1, 1, 1, 0, 1, 0, 1, 0, 1},         99 99 99 3  99 15 99 19 99
 {1, 0, 0, 0, 1, 0, 1, 0, 1},   -->   99 6  5  4  99 14 99 20 99
 {1, 0, 1, 1, 1, 0, 1, 0, 1},         99 7  99 99 99 13 99 21 99
 {1, 0, 0, 0, 0, 0, 1, 0, 1},         99 8  9  10 11 12 99 22 99
 {1, 1, 1, 1, 1, 1, 1, 1, 1}}         99 99 99 99 99 99 99 99 99

Examples (not allowed outputs and inputs):

11111 10101 10101 10001 11111  --> 9999999999 9900990699 9901990599 9902030499 9999999999

Notes:

  • as seen above, the input and output must be bunch of numbers separated by whitespaces, commas, full stops, newlines, parenthesis (and so on), and mustn't be in a single row

  • you can output 01 instead of 1

  • cases where the distance is over 99 don't need to be covered

  • the program doesn't need to solve the maze, just to find the distance from the start

  • two fields connected diagonally aren't next to each other

  • it's , so the shortest answer in bytes wins!


\$\endgroup\$
4
  • \$\begingroup\$ it makes more sense to show walls as ## or || etc, instead of an integer \$\endgroup\$
    – FlipTack
    Nov 5, 2016 at 21:56
  • \$\begingroup\$ The restrictions on the format on the output and inputs don't add anything to the challenge (imo) : the interesting part is solving the maze. \$\endgroup\$
    – Dada
    Nov 6, 2016 at 10:56
  • \$\begingroup\$ @Dada They allow the program to be shorter, at least in most languages I know. \$\endgroup\$
    – user60199
    Nov 6, 2016 at 13:55
  • \$\begingroup\$ @Flp.Tkc See the comment above. \$\endgroup\$
    – user60199
    Nov 6, 2016 at 13:56
1
\$\begingroup\$

Defs need to fix up layout

[Very much a WIP]

Maze battle

In this challenge, bots will team up, navigate around a maze and try to destroy the enemy team's artifact, and protect their own.

A maze might look like this. Note that the bots will receive numbers rather than ascii art, which represent their vision, and the objects they see.

+---------+-+---+-------+++-+-+---+-+-------+-+-----+
|         | |   |    #  | | | |   | |       | |     |
+-+ +-+-+ + + + +-+-+ +-+ + + + + + + + +-+-+ +-+ + |
|   |         |         |     | |   | | |   |     | |
| +-+-+ + +-+ +-+ + + +-+ + +-+ +-+ +-+ + +-+ +-+ + |
|       | |   |   | |     | |   |         | |   |   |
| +-+-+-+ +-+-+-+ + + + + +-+ +-+-+ +-+ + + + +-+ + |
|   |     |       |   | |   |   |     | | |       | |
| + + +-+-+ +-+ +-+ +-+ +-+ + +-+ + + + + + +-+ + + |
| |       |                 | |   | | |     |   | | |
| + + + +-+-+-+-+ +-+-+-+ + + +-+ +-+ + +-+-+-+ +-+-+
| | | |     |   | | |     |     |   | | |           |
| +-+ +-+ + +-+ +-+ +-+-+ +-+ + + + + + +-+-+ +-+ + |
|   | |   | |           | |   | | | |   | | |     | |
| +-+ + +-+ +-+ + + + +-+-+-+ +-+ +-+-+ + + + +-+ + |
|     | |       | | |   | | | | | |         |   | | |
| + + +-+ + + + + +-+ +-+ + +-+ + +-+ +-+-+ +-+ +-+-+
| | |   | | | | |   |   |       | |   | |       |   |
| +-+ + + +-+ +-+-+-+ +-+ +-+-+ + + +-+ + +-+-+ +-+ |
|   | |   |         |       |   |       |   |       |
+-+ +-+-+ +-+ +-+ +-+ + +-+ + + + +-+ +-+ +-+ + +-+-+
|   |   |   |   |   | | |     |     |   | |   |     |
| + +-+ +-+ + +-+-+-+ + + + +-+-+-+ +-+ + + +-+ +-+ |
| |       |   |   |     | |         | |   | |       |
| +-+-+ + +-+ +-+ + +-+-+-+ + + + +-+ +-+ +-+-+ +-+ |
| |   | | | |       | |   | | | | |   |     |     | |
+-+-+ + +-+ +-+-+-+-+ +-+ +-+ +-+ + +-+-+ +-+ +-+ + |
| | | | |   |           |     | |     |       | | | |
| + + +-+-+ + +-+ +-+-+ + +-+-+ +-+ +-+-+-+ +-+ +-+-+
|   |     | | |             |   | |   | |     |     |
+-+ +-+-+ + + + +-+ +-+-+-+ +-+ + +-+ + +-+ +-+ +-+-+
|   | |   |   |   | |     | |   |     |   |       | |
| +-+ + +-+-+ + +-+ + + +-+-+ + + + + + +-+-+ + + + |
|       | |           |       |   | | | |     | |   |
| +-+-+ + +-+ + +-+-+ + + +-+ + +-+-+ + +-+ + + +-+ |
|   | |   |         | | | |   |     |   | | | | |   |
+-+ + + + + + + +-+ + +-+-+-+-+ +-+-+ +-+ +-+-+ + +-+
|       |   | | |           |     | | |   | |       |
+-+-+-+ + +-+-+-+-+-+ + +-+-+ +-+ + +-+ + + + +-+ + |
|     |   | |         |     | |     |   |       | | |
+-+ +-+ +-+ +-+ + +-+ +-+-+ + + +-+ +-+ +-+ +-+ +-+-+
|     | | |     |   |         | |           |   |   |
+-+ +-+-+ + +-+-+ +-+-+ +-+-+ +-+ +-+-+-+-+ + +-+ + |
|               | |   |                 |   | |   | |
+-+-+ +-+-+-+ + + + + +-+-+-+-+-+-+ +-+ + + +-+ +-+ |
|       |   | | |   |   |           | | | |       | |
| +-+-+ + + +-+ +-+ + + +-+-+ +-+ + + + +-+-+-+-+ + |
| |       | | | |   | |       |   |     |           |
+-+-+ + +-+-+ + + +-+ +-+ +-+-+ + +-+ + + +-+-+ +-+-+
| |   |     |   | | |   |       |     | |     |     |
| + +-+ + + + + + + + + + + + + +-+-+-+ +-+-+ +-+-+ |
|       | | | |    #  |   | | | |       |     |     |
+-------+-+-+-+-------+---+-+-+-+-------+-----+-----+

Bots receive information about their current environment. They will receive a 8 lines of numbers, representing their view in each of the directions. vision is blocked by walls, and walls only, so at the end of the line of sight is a wall.

Numbers represent the following things:

  • 0 represents a space with nothing in it.
  • 1 represents a friendly bot
  • 2 represents an enemy bot
  • 3 represents your team's artifact
  • 4 represents the enemy team's artifact

To destroy the enemy's artifact, you have to shoot it a bunch. heaps. So, you probably want to bring that artifact to your team, or your team's side, so that you can shoot it more.

When you die, you respawn after 5 turns.

At the start of the round, bots spawn into the first third of the maze on their side. when respawning, they also spawn into this area.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Nice idea! Would be better if it was Java :D \$\endgroup\$
    – user41805
    Nov 6, 2016 at 10:20
  • 1
    \$\begingroup\$ @KritixiLithos: No \$\endgroup\$ Nov 8, 2016 at 23:28
1
\$\begingroup\$

Format an XML file

Your task is to parse an XML snippet (not necessarily an entire file) and format it. I am explicitly making this simple to encourage extremely golfed code.

The formatter should transform XML like this:

<?xml version="1.0" encoding="UTF-8"?>
<body>
    <div class="community-option">
        <input id="communitymode" name="communitymode" type="checkbox"/>
        <label for="communitymode" title="Marking an answer community wiki encourages others to edit it by lowering the reputation barrier required to edit. However, you will not gain any upvote reputation from it. This cannot be undone.">community wiki</label>
        <a href="www.hoehel.be"><i>My inner web developer hates me</i></a>
        <b>BOLD</b>
    </div>
    <iframe/>
</body>

into formatted text like this:

?xml
body
    div
        input
        label
        a
            i
        b
    iframe

Rules

The main element does not get a indent, every layer deeper does get an extra indent. An indent is either a tab or 4 spaces.

When there are multiple root elements, they simply are added below eachother with no indentation. The ?xml element is not different from any other element.

The XML will have a space after each element name, so if there is a CDATA element, it will be formatted as <![CDATA[ (the data)]]> and will need to be formatted as ![CDATA[ at the correct indentation.

Also, the XML will not include > and < except for opening and closing elements.

\$\endgroup\$
4
  • \$\begingroup\$ In XML, a right angle bracket > is allowed in an attribute. So perhaps include that as a test case, or explicitly state that this will not happen. Also, what qualifies as an indent? One space? Four spaces? A tab character \t? \$\endgroup\$
    – Sanchises
    Nov 8, 2016 at 11:31
  • \$\begingroup\$ 1. The example is invalid because (a) it doesn't have a single root element; (b) the input element isn't closed. 2. This isn't really pretty printing XML. It's pretty printing the element structure of XML. 3. There are a whole bunch of important test cases which are missing. CDATA. Namespaces defined at the root element. Namespaces defined on non-root elements. Elements expanded from entities. There are bound to be some others if you look at the spec. \$\endgroup\$ Nov 8, 2016 at 17:08
  • \$\begingroup\$ @sanchises Reworked the question to avoid problems there. \$\endgroup\$
    – vrwim
    Nov 8, 2016 at 21:11
  • \$\begingroup\$ @PeterTaylor (a) I'll include that it can be a snippet. (b) Didn't notice it, took some HTML from stackoverflow source code, don't blame me :) 2. Renamed to "formatting" the XML 3. Added workaround for the special cases I could find. \$\endgroup\$
    – vrwim
    Nov 8, 2016 at 21:15
1
\$\begingroup\$

Build a learning 20Q bot

Twenty Questions is a verbal game where an 'asker' asks you a series of yes or no questions about an object that you're thinking of. If the 'asker' gets the object correct after twenty questions, then the 'asker' wins the game. If the asker does not guess the question right after 20 questions, then the 'thinker' wins.

Input:

Your program needs to take 4 different inputs, non simultaneously. Those three inputs are:

  • A category (valid categories are Animal, Food, Action, Person/Character, Thing)
  • A yes / no input from the user to answer the questions.
  • A question input to 'teach the bot', and an object input to show the bot what was being described.

Output:

Your program needs to play a game of 20 questions, wherein it follows this structure:

  • Ask a category like so: "Select a category (Animal, Food, Action, Person/Character, Thing):"
  • Ask questions based on the category.
  • Make a guess of the object like so: "Is it a "[guess]"?".
  • IF the guess was wrong, ask what the object was, and inquire the difference between the guess and the object described.
  • your program must stop at 20 questions and make a guess. it doesn't have to be random.
  • your program must progressively 'learn' as it is played. It must be able to add new questions and objects to guess.

Examples:

⇨Select a category (Animal, Food, Action, Person/Character, Thing):  
⇦Food  
⇨Is it  ?  
⇦No  
⇨What is it?  
⇦Marmite  
⇨What is the difference between  and Marmite?   
⇦It has a saying 'You either love it or hate it'  
⇨  
⇨Select a category (Animal, Food, Action, Person/Character, Thing):  
⇦Food  
⇨Does It has a saying 'You either love it or hate it'?   
⇦No  
⇨Is it Marmite?  
⇦No  
⇨What is it?  
⇦A Carrot  
⇨What is the difference between Marmite and A Carrot?  
⇦It has lots of vitamin C   
⇨  
⇨Select a category (Animal, Food, Action, Person/Character, Thing):  
⇦Food  
⇨Does It has a saying 'You either love it or hate it'?   
⇦No  
⇨Does it It has lots of vitamin C?  
⇦Yes  
⇨Is it a Carrot?  
⇦No  
⇨What is it?  
⇦A Yam  
⇨ What's the difference between a Carrot and A Yam?  
⇦It grows underground.  
⇨  
⇨Select a category (Animal, Food, Action, Person/Character, Thing):  
⇦Food  
⇨Does It has a saying 'You either love it or hate it'?   
Yes  
⇨Is it Marmite?  
Yes  
⇨Yay, I Win!  
⇨  
⇨Select a category (Animal, Food, Action, Person/Character, Thing): 

Etc.

\$\endgroup\$
2
  • \$\begingroup\$ Pass2: How Can I improve this? I would like some critiques before I post. \$\endgroup\$
    – tuskiomi
    Nov 16, 2016 at 19:51
  • \$\begingroup\$ Possible duplicate: codegolf.stackexchange.com/q/57171/32686 \$\endgroup\$
    – Blue
    Feb 10, 2017 at 15:14
1
\$\begingroup\$

Produce a quine of length n

Write a program that, given a number n, produces a quine in your language of length n. If your language cannot have a quine of that length, it does not need to be generated.

Standard loopholes are forbidden.

The quines that are generated must be proper quines.

Remember, this is , so the code with the smallest number of bytes wins.

\$\endgroup\$
7
  • \$\begingroup\$ Is there a minimum/maximum n? Plenty of languages don't have a 1 or 2 length quine, for example. \$\endgroup\$
    – Geobits
    Nov 17, 2016 at 20:28
  • \$\begingroup\$ @Geobits How botu now? \$\endgroup\$
    – Oliver Ni
    Nov 18, 2016 at 0:03
  • \$\begingroup\$ Seems reasonable. I'm not sure how to prove it for some languages, but I'll leave that to answerers :) \$\endgroup\$
    – Geobits
    Nov 18, 2016 at 0:13
  • \$\begingroup\$ The ! in the title made me think that the quine had to have length n factorial, whereas the text says n. You should remove the ! in the title. \$\endgroup\$
    – Fatalize
    Nov 18, 2016 at 9:11
  • \$\begingroup\$ @Fatalize Okay. Done. \$\endgroup\$
    – Oliver Ni
    Nov 18, 2016 at 16:09
  • \$\begingroup\$ Regarding what @Geobits said, with the current wording I'm definitely worried since answerers would need to prove that they've got the minimum length quine covered. \$\endgroup\$
    – Sp3000
    Nov 19, 2016 at 5:54
  • \$\begingroup\$ Sp3000's concern is definitely valid. It would mean that you can only answer in languages where the shortest known quine has been proven to be optimal. Also, I'm not sure it's terribly interesting in most languages, because you can usually just insert spaces or no-ops into one or two places and the code remains a quine. \$\endgroup\$ Nov 21, 2016 at 15:23
1
\$\begingroup\$

Rearrange the Words!

Given a string of text containing some words, which are separated by spaces, determine the best arrangement to fit it in the shortest number of pages.

If a word is shorter than the length of a page:

  • If the word fits on the latest page, it stays on that page
  • If the word does not fit, it goes to the next page.

If a word is longer than the length of a page, it stays on that page and overflows to the next page.

Words have one character between them if they are on the same page.

For example, if the length of the page was 10, and my words are hello my name is oliver ni!!, it would fit like this:

hello my
name is
oliver
ni!!       # 4 pages

However, one of the ways to rearrange it can get a shorter number of pages:

hello name
oliver is
my ni!!    # 3 pages

So the shortest way in this case would be 3 pages.

Remember, this is , so the code with the fewest bytes wins.

\$\endgroup\$
5
  • \$\begingroup\$ 1) Does the greedy algorithm give an optimal solution? If not, there should be test cases specifically for it. 2) A few test cases would be good, covering edge cases such as everything fitting on one line 3) Can the length of the page be shorter than the longest word? Is that valid input? 4) Is the output the arrangement or the number of pages? \$\endgroup\$
    – Sp3000
    Nov 21, 2016 at 1:15
  • \$\begingroup\$ This problem is well-known to be NP-complete. As such, the greedy algorithm can't possibly be optimal. I imagine that code-golf solutions will just brute-force the solution, given that (for an NP-complete problem) it's very hard to objectively enforce a faster-than-brute-force algorithm. \$\endgroup\$
    – user62131
    Nov 21, 2016 at 1:19
  • 1
    \$\begingroup\$ An example where the greedy algorithm fails: word lengths 10, 6, 5, 3, 2, 2, page length 14 (this assumes that spaces have already been "factored in to" the word and page lengths by adding 1 to each). The greedy algorithm gives (10, 3), (6, 5, 2), (2). The best answer is (10, 2, 2), (6, 5, 3). \$\endgroup\$
    – user62131
    Nov 21, 2016 at 2:04
  • \$\begingroup\$ @ais523 I'm pretty sure the greedy algorithm will give an optimal solution. \$\endgroup\$
    – Oliver Ni
    Nov 21, 2016 at 5:28
  • \$\begingroup\$ @Oliver ais523's example is actually 9, 5, 4, 2, 1, 1 with page length 13. The greedy algorithm gives (9 + space + 2), (5 + space + 4 + space + 1), (1), but the optimal solution is (9 + space + 1 + space + 1), (5 + space + 4 + space + 2). \$\endgroup\$ Nov 21, 2016 at 15:45
1
\$\begingroup\$

Change the type of a variable without introducing any new identifiers while preserving a value resulting from the conversion of the original one

Consider the variable which type you should change is declared/defined inside a function. Another thing to consider is that there wouldn't be any other identifiers manually defined/included before your function and the variable inside it (this includes referring to standard header/modules too). Also you aren't allowed to change the value or meaning of any existing identifiers (if any) except a after your code is finished, compared to before it started executing. (Of-course this doesn't forbids you to actually change them but after your code is finished they must be in the same state as before it was entered in, except a of-course)

As identifiers I mean reserved names of functions, variables and etc.

Example in C:

void f() //no identifiers defined/included prior
    //the function can't have any parameters

{ //inside function block

    int a = 67; //assign some constant value here

    //... your code here

    //no new identifiers introduced
    //and no existing one have changed meaning (or value) after this point
    //except 'a' of-course

    a ; //here 'a' must have different static type
        //with a value resulting from the conversion
        //of the one stored previously in 'a'


    //You are allowed to include libraries/modules (identifiers) here in
    //order to show us the value and type of 'a'
    //The unused statement above is used only as valid syntax containing 'a'
}

Of-course the above snippet is just a sample. In case of using actually C you are allowed to add all other kind of stuff (like additional block scopes, etc). The only important thing to target is that after you have declared some variable in your function you have to write some magic with the requirements given.

This question have intended solution in C. I'm not sure how applicable is it for other languages though because it depends on the concept of having some names (identifiers) referring to certain entities. Also it needs types and object values defined too.

The initial and target type of a aren't specified. Also if the identifier a of the variable is not allowed, you can use one that is.

\$\endgroup\$
3
  • \$\begingroup\$ I think I understand now your purpose better. This is a programming-puzzle, and we certainly allow them. For that purpose, I think its a good idea to limit it to C. That said, you should be very explicit about where they are allowed to put code and what code they can write. (You have it in your comments, but I'd add it in the post) \$\endgroup\$ Nov 21, 2016 at 16:33
  • \$\begingroup\$ @NathanMerrill Thanks for the feedback! Yeah - you are probably right to limit this question as C only. \$\endgroup\$ Nov 21, 2016 at 16:49
  • \$\begingroup\$ Is any C standard allowed? E.g. I have a solution which only works with C99. \$\endgroup\$ Nov 21, 2016 at 22:05
1
\$\begingroup\$

Pluralize Words

(DISCLAIMER: In this challenge, several exceptions and rules are not accounted for. Many plurals are based on sound and not spelling, and still others have no set guidelines. Please do not use this as an actual set of rules for making plurals.)

A lot of questions here require using different Algebras. ... Algebra? Algebrae?

OK, that's it. We're going to get to the bottom of this.

Your challenge is to write a program that accepts a word as input and outputs the plural (in standard English rules).

Rules on making plurals

  • Words ending in s, x, z, ch, sh, o, ex, or ix have es added to them. (For example, box -> boxes)
  • Words ending in y preceded by a consonant have the y removed and ies added to the end. For example, cherry -> cherries. (Words like day with a vowel before the y are treated as normal.)
  • Words ending in f or fe are treated as normal.
  • Words ending in us have the ending changed to i. (For example, alumnus -> alumni)
  • Words ending in is have the ending changed to es. (For example, oasis -> oases)
  • Words ending in um are changed to a. (For example, medium -> media)
  • Words ending in a are changed to ae. (For example, antenna -> antennae)
  • All other words have s added to the end.

Several rules have been omitted for simplicity:

  • You do not have to account for irregular plurals like sheep. If sheep was inputted, you would return sheeps.
  • The o/f/fe/ex/ix rules have lots of exceptions. knives, matrices, etc. I can't find any pattern, however, so these are simplified to one rule.
  • chateau -> chateaux, man -> men, child -> children, foot -> feet, and mouse -> mice have been left out due to ambiguity. You can replace these with chateaus, mans, childs, foots, and mouses, respectively.
  • Words are counted based on spelling, not sound. TimmyD mentioned in the Sandbox:

    For example, Czech (as in, a person from the Czech Republic) goes to Czechs ("checks") since the ch is pronounced like ck.

    Here you would output Czeches (as it is spelled with a ch).

Input

A single word, like challenge. The input will only contain letters a-z.

Output

The pluralized word, based on the rules above, like challenges. You may have a trailing newline.

Output may be case-insensitive.

Test Cases

algebra
algebrae

shoe
shoes

fax
faxes

datum
data

bunny
bunnies

qlwlsh
qlwlshes

Meta Questions

UPDATE: I've answered these questions myself. Do you guys think it's ready for posting?

  • Is this a duplicate? (No, other similar challenges have different scoring)
  • Are there any special cases I left out? (Probably but they'd over-complicate things)
  • When researching this I discovered there are a LOT of little rules. I've omitted some here, but is this too complex to be a feasible challenge? (No)
    • In addition, have I left out too many rules? (Adding any more would make it too complex)
\$\endgroup\$
7
  • \$\begingroup\$ The problem is that English handles its pluralization (and a/an distinction) based on the vocal pronunciation, and not by the letters themselves. For example, Czech (as in, a person from the Czech Republic) goes to Czechs ("checks") since the ch is pronounced like ck. I think the simplifications you have here are OK, so long as you're very explicit that there are a lot of exceptions that aren't accounted for. \$\endgroup\$ Aug 5, 2016 at 15:13
  • \$\begingroup\$ Also, relevant chat discussion \$\endgroup\$ Aug 5, 2016 at 15:21
  • \$\begingroup\$ @TimmyD Interesting. I'll double-check the edits I made to make sure those strange cases don't slip through. \$\endgroup\$ Aug 5, 2016 at 15:26
  • \$\begingroup\$ I think the f rule could be left in, since it's pretty consistent that f and fe become ves. I can only think of a few exceptions to that rule. A better title might be "Pluralize Words" (since pluralize is actually a word). I think if you just need to follow the rules and not worry about exceptions, it wouldn't be too complex. \$\endgroup\$ Aug 5, 2016 at 15:30
  • \$\begingroup\$ Also possible duplicate of this and this. However, I prefer this one to the others since this explicitly states the rules your program should follow. \$\endgroup\$ Aug 5, 2016 at 15:31
  • \$\begingroup\$ @BusinessCat Those are different, scoring is based on the number of wrong words there. Here, this is a code-golf for shortest code that properly prints plurals (with some exceptions.) \$\endgroup\$ Aug 5, 2016 at 15:47
  • \$\begingroup\$ My answer to "Is this too complex to be a feasible challenge?" is "Yes". Natural language processing in general (and especially where the language is English) is a better fit for challenges which score by performance against a large suite of manually curated test cases than pure code-golf. \$\endgroup\$ Nov 23, 2016 at 15:54
1
\$\begingroup\$

Find the Mersenne Twister seed

Given a sequence of N 32-bit unsigned integers, find a 32-bit seed for the Mersenne Twister PRNG (specifically, MT19337) such that the first N 32-bit unsigned integers produced are the input sequence.

Rules

  • Solutions will be tested and timed on a free Cloud9 workspace (512 MB RAM, 1 8-core CPU). Full CPU specifications can be found in this Gist.
  • There will be 50 sequences used to time solutions, each containing at least 20 and at most 50 integers. All sequences will be generated using CPython 3.4's MT19337 implementation (the source code can be found here).
  • Brute force (by way of iterating through all possible seeds) is not allowed, as it would take an obscene amount of time to run all 50 timing cases with such a solution.
  • Hard-coding seeds is not allowed, as it undermines the point of this challenge.
  • I reserve the right to change the timing sequences to different sequences of similar complexity if needed, such as in the event that two seeds are found for the same sequence.
  • Please include instructions on how to run your solution, including installation instructions for any software that is not included with a standard Ubuntu installation.

Test Cases

Note that the seeds given may not be the only seeds which produce the given sequence (if other seeds are found, please let me know). These smaller test cases are provided for verification purposes only, and will not be used for scoring.

[859552199, 418371998] -> 765976290
[3575669016, 3345750943, 1425199743, 3641622143, 468413882, 1201820413, 440223465, 4032367274, 1303769163] -> 3089232394
[3301913871, 2465802243, 3612732284, 2327984155, 3125193467, 1186355054, 3586515345, 1676699096] -> 3317482306
[1187719129, 4252341260, 3652285377, 2546267472, 259146681, 3132024105] -> 618872552
[567043356, 3386297553, 3291980436] -> 2064328469
[2371812852] -> 3402334589
[2169144927, 1612138200, 2367065602, 3106703576, 3360699020, 2044583150] -> 1508970517
[4264152408, 93510901, 2140553491, 2298459244, 3988997159] -> 3805008435
[815695699, 3390998580, 1837233431, 35472600] -> 1298560578
[2785297506, 692193253, 1505379580, 2810620241, 2299478120, 233996693] -> 1856467397

Timing Cases

These are the 50 sequences, along with the respective seeds that produced them, that will be used for scoring solutions. Once again, if any other seeds are found that produce the given sequence, please let me know.

[3626764237, 1654615998, 3255389356, 3823568514, 1806341205, 173879092, 1112038970, 4146640122, 2195908194, 2087043557, 1739178872, 3943786419, 3366389305, 3564191072, 1302718217, 4156669319, 2046968324, 1537810351, 2505606783, 3829653368, 3900315155, 938204377, 2167613558, 598176026, 1210484339, 600203567, 3246154361, 407295012, 2655874620, 3433407905, 1075916535, 4240245955, 3907330410, 2287343378, 4221031477, 3028691745, 3479856542, 2585149702, 3874773259, 631194409, 1332073689, 424185324, 3134603515, 316721330] -> 0
[3393124633, 2450474977, 1966463085, 3673681320, 1729202683, 1167867720, 325264180, 3917283871, 100160351, 791524511, 2930202830, 3113143968, 1502082504, 1809749915, 418618347, 1516663034, 578608165, 3127414055, 3472262548, 308161377, 135281507, 4131277967, 3953099834, 1042116387, 1985078128, 1789355090, 2975834429, 2756451880, 1853842973] -> 80552670
[3501423986, 1904817736, 3722254077, 4209805889, 624241735, 3072497443, 3348948634, 948724253, 2775088165, 653145320, 699931897, 2271688288, 965327734, 3611254581, 4021716510, 3489649715, 590896686, 2492882151, 2449284001, 1709766651, 2373030892, 1906330141, 3281376004, 542155191, 654946082, 3866707349, 675539429, 3153689518, 2192976919, 2369760520, 1789539597] -> 123863960
[161627675, 758641073, 3882484966, 1142624247, 4128058828, 2063104815, 1532506610, 4133456839, 2543581728, 18178196, 2276191025, 6278001, 3128406689, 2146406812, 39141315, 1050571803, 2511216100, 2411368419, 3269811767, 815334548, 3812711899] -> 178693462
[1006603821, 2040840228, 2217261808, 3301867033, 3944952417, 1692780898, 40334807, 2573488161, 1195239502, 1063781197, 758636410, 1944506134, 1022411961, 3709537934, 175021745, 3183030828, 1196557078, 11946672, 1551403327, 4143434962, 3283348277, 1825370082, 2293735756, 429108850, 745523037] -> 227497455
[2252079699, 1086590868, 525211993, 209343944, 1861419840, 2057307759, 2083384643, 2590024292, 4135416707, 3508386594, 1358765199, 3089076939, 3719484781, 516962076, 4107295833, 723033883, 1857756581, 434940583, 919038598, 2441529245, 1687894943, 13982251, 1940221612, 220848786, 1518435648] -> 260282679
[1821793358, 3054510267, 1906284293, 3380915352, 2593544407, 3915598365, 216223976, 4179796969, 2252681786, 35956624, 2373486206, 877849443, 3555235079, 3667331109, 2387597923, 2892840935, 1697182374, 4016309999, 3498537950, 2841634562, 3522184350, 1705717875, 4162597164, 2056807023, 2211204973, 3267303967, 3919558114] -> 325889376
[1201670212, 746140380, 1320204973, 751872422, 3310421711, 1963946901, 625374447, 2435010607, 3055683554, 3426449636, 4008426547, 337682689, 4056318014, 2315028303, 3896431367, 3153777187, 595649858, 3945299365, 113301178, 437820390, 2219035549, 284287245, 3156511236, 3954981533, 599197497, 3946167954, 3728124202, 733618224, 2033404503, 2973733622, 2705618778, 3966553008, 4036118888] -> 389267947
[1910148876, 4015517082, 1214608849, 988091919, 2525094197, 81939600, 3978887728, 2847303411, 66064807, 3605598571, 819502713, 233898591, 1970756897, 2621444751, 213250142, 3439913424, 1332746382, 4063692407, 869169264, 660008864, 2526902458, 3155477426, 1686496804, 3877857092, 4248058769, 2220603751, 465407251, 3418337662, 362811108] -> 424148743
[2663034465, 347641133, 1266329350, 494434286, 24416336, 1697535896, 233051569, 1134030615, 821790629, 1645020605, 2310228737, 63596966, 3832219398, 465243130, 4070794284, 1062758865, 2070536142, 2272514237, 440192702, 3490367376, 3000125608, 1175130963, 339129292, 1200804986, 3560746354, 1043913893, 489469329, 3588157041, 415367051, 1506938118, 519839008, 3921307375, 1017013313] -> 481818733
[2125426152, 580419999, 1942656966, 733532664, 1002041383, 4276401064, 3164003602, 1600445806, 87486541, 585241213, 1822489492, 3670405099, 2371866217, 293071217, 1698095716, 2860716495, 4096732631, 860271933, 1698519068, 1453446230, 2296564613, 1034887983, 3124580892, 3613882243, 3142206150, 1201496338, 262241539, 2658580629, 75299337, 1543495990, 1079614000, 1988996951, 1393947112, 3686457188] -> 503218192
[849928291, 3109119200, 641398141, 953565598, 1651963094, 2973763708, 2409024299, 2638872282, 3438675501, 2024561790, 2574711112, 2224233243, 2145875524, 2483785498, 832036542, 2756591965, 804169437, 1610259885, 1727659540, 3804671151, 2651460465, 3679117113, 3392652401, 4291100134, 3315401681, 4150630548, 3255282492, 1793428708, 4213220288, 1275054855, 3395683809, 126422719, 747072718] -> 529806420
[3795382423, 2318193600, 2941259533, 1429473204, 3841712189, 908410440, 2163447895, 2266401416, 1962272288, 2172290597, 903602965, 2493475709, 1557270830, 1269693466, 1882416966, 1675172531, 2727910931, 67882201, 982110502, 922191612, 1147478737, 1527639226, 1162436584, 3427111171, 1012039523, 775426178, 2235111095, 838473449, 3547292154, 2331447259, 2482093779, 3522096001, 978885775, 911597256, 4199754157, 884328339, 3958245046, 3701693539, 2205845644, 737996384] -> 594670421
[2281257517, 3184614238, 760843542, 2349085191, 3946149756, 3843515781, 357391440, 280771960, 1523563345, 1988608601, 3428233753, 100999796, 1858706576, 3053822297, 2013347998, 2869736987, 3049191880, 2683304507, 2165662057, 1644801829, 3174344328, 516799881, 2817748912, 680940874, 60488796, 440310808, 4238771580, 3333869324, 3437732706, 2291819087, 2904810286, 643100619, 2444662123, 2814934785, 3198564042, 3050641347, 2644737611, 1044358220, 2729428974, 2696207835, 1949284287, 2602160488, 4077269219, 843097934] -> 608761482
[2459044101, 3628291690, 21901316, 1607776779, 574126446, 2632595613, 1898457307, 1993218217, 2268071755, 2262630078, 1334308000, 2756814507, 1322265974, 493521136, 3513003023, 1998755513, 501729387, 461623974, 2703701229, 3074392802, 2895338933, 1257991758, 1147599903, 2188879650, 2802233695, 1049885503, 67969151, 3855902849, 1481701505, 2592817148, 3215907335, 3924969407, 91996333, 857125517, 3408363147, 4006870634, 998389513, 1316925910, 1621658875, 2583060764, 3809067813, 4122609293, 3970592027, 529557207, 1717219729, 2504378950, 418151974, 1944676036, 4136632810, 2747386509] -> 672575322
[58833619, 2580439730, 3693390914, 2286941505, 2380251005, 860188183, 1775128121, 1286129564, 1885665593, 2208299577, 4157266729, 3426550994, 3918528183, 4277973044, 3399609402, 1027156209, 2127983039, 4014806283, 1680366681, 2338809246, 2450101289, 2369487851, 2470761981, 4146252501] -> 758102662
[1228778451, 3161629785, 956090791, 2661866534, 3797423759, 387813121, 686718911, 1671912681, 3122216050, 3708361254, 2450007821, 562470295, 2371567740, 594715145, 1539207036, 1044745741, 3799733486, 3957279143, 3072889407, 43156136, 564713293, 3478075046, 3706967146, 3687044887, 992776898, 3807405066] -> 829276193
[4181681092, 472808862, 2820379353, 1971138909, 957029949, 383690688, 1619203644, 40060279, 799380031, 2522476881, 3052161194, 1101783645, 550394884, 1003243703, 1139176364, 637909704, 1746995412, 3569010375, 2962331845, 1221693446, 1622613434, 2503259347, 1956882342, 3173044265, 1239439145, 842693462, 2538205226, 2451274505, 4212820092, 3591867315, 1233020299, 978021001, 3148810648, 1811827712, 2638973530, 815364991, 1169900461, 1109925685, 856009157, 3254416301, 2037813477, 3945026418, 1535198958, 4259784019, 573350683, 1682977388, 1817703645, 2576589136] -> 898248134
[3182465441, 38281954, 424174823, 2654611156, 2877159272, 723093605, 1443837986, 3392781854, 2463922103, 4286449851, 538962217, 2130457280, 2178815165, 3486677232, 4058242555, 491907811, 162839736, 1759357975, 870141283, 1495756753, 1216746993, 1937724479, 1514235325, 4184006461, 3436845854, 2401877503, 610797147] -> 913459250
[1149034119, 2642531102, 1662163608, 3290983280, 819699523, 515983953, 2696922239, 2166479741, 1179733281, 2022256392, 1626594590, 543353369, 3692263091, 2392093428, 4014491227, 1041518429, 1713650051, 3538550903, 3376348599, 4277108217, 2867735513, 82177527, 10764183, 2126826329, 1028783725, 2271873691, 213268477, 2609718986, 3495904404, 913207638, 1265558725, 2980124058, 303469040, 253105205, 495410356] -> 931867201
[1077541173, 465200833, 3196368211, 1288748206, 2815478016, 1065298665, 2884065004, 392702413, 3587996620, 2894220485, 3226548573, 145951050, 956741233, 2456765795, 3978933657, 1007424556, 2169150234, 3651822773, 1565891297, 510586439, 2219790712, 422126653, 1640535295, 2992880885, 3691821384, 1555208492, 2642710071, 2625348100, 578265950, 592730275, 2092195932, 2504727970, 2149376041, 3179917702, 141987426, 2680075044, 656985656, 2153196909, 4149347932, 2216899428, 2639954700, 3190665042, 2786390314, 2974431514, 1505784370, 3602363995, 1699665616, 327189341, 335160466] -> 945442081
[1284631810, 3717268552, 2270237312, 1334241593, 1477854231, 3138477902, 3837857694, 3586498067, 1959233909, 3891506078, 2756512687, 2553842301, 964459746, 1395510385, 1185295577, 3096625618, 3145085801, 2953203657, 412902939, 3850708910, 2893328412, 2046860068, 86811187, 1188173782, 1294786028, 3044338056, 1040690464, 2128428491, 2571424043, 467837042, 3752155615, 4020048256, 3119445970, 2240289832, 1491368301, 3651270856, 2456196179, 378459336, 188104463, 777143930, 1824526143, 4060407078, 3866701738] -> 1005490735
[329511653, 2198540059, 2154958918, 378488687, 1460553211, 2529097663, 2295211009, 68583162, 1430570391, 1601101442, 1075009348, 2795773614, 833830658, 903181786, 633114581, 3292534356, 3245176784, 2582500259, 3943169203, 1130082435, 3079387854, 3150805871, 1721482617, 2291158702, 3225790458, 1468813727, 862011357, 4268175908, 3661137987, 464141661, 3956758980, 353701536, 1341361227, 809582799, 3968372465, 4111098095, 2898048807, 1509470117, 3255194829, 1330296075, 3520527115, 3736908846, 168999059] -> 1056211089
[1981947965, 3374825360, 3953254353, 1846368367, 1512467473, 3858309918, 4274851313, 787575622, 1876080592, 73919936, 3951066372, 730226758, 3289279637, 768907525, 1773361296, 821210337, 823248190, 869737395, 1360958003, 37854528, 426098214, 2732039516, 64754302, 3276807872, 3816769165, 991587659, 2262236344, 2500333010, 544193426, 1576372318, 2228843007, 2361635236, 2149913894, 3651360213, 2399010654, 4269441712, 1500948518, 3962883634, 1885037482, 2608182179, 3516218188, 513897987, 4242749462, 3892663321, 3922003874, 2123606394, 1383207752, 2867973529, 3840556114, 2969243741] -> 1071722183
[2514263486, 742731713, 3234620175, 3101660088, 2571087369, 3985627296, 3534135449, 2957356517, 2720311929, 2985074784, 2621199558, 3407431088, 2711831197, 1247421057, 3794320157, 1180925811, 1569942151, 2629267152, 173488457, 1406704148, 3969219352, 291552269, 1333806964, 2203738485, 1554560925, 496218017, 1379546509, 2539796280, 4118468566, 2328295795, 884528669, 123600717, 1597383076] -> 1093875318
[1521547521, 982639096, 3108583938, 3860926389, 1477036165, 2087376039, 953332718, 1432039007, 836148138, 3081500185, 396473811, 1621365414, 3796659618, 3939606659, 4248871833, 2917576264, 2729341943, 2981171481, 2311970081, 150264587, 2215220955, 995666639, 452785817, 758560294, 2134005122, 39617150, 1283053470, 4198921194, 2492185018, 595457083, 1042642207, 545670342, 4068770955, 749869737, 984770127, 663196981, 1849907933, 1443537561, 3860175505, 1016163998, 3260982442, 3769639327, 2728953690, 1556597597, 1877966580] -> 1155984918
[1198705327, 1935517658, 503589232, 1577874702, 627636752, 3338218922, 1157893341, 3491377096, 158028724, 2472091015, 1488124620, 2401465711, 3064309912, 1501000204, 3549612642, 2584717560, 1744885213, 4114571438, 1885581118, 2912594621, 3206412254, 4218195409, 2855464167, 2517461088, 685010709, 2000660923, 3562767265, 1193468772, 1470300123, 819551295, 2007863203, 980161306, 717575858, 2022655390, 1011703442, 1190149434, 182438707, 4158211886, 2175561856, 3060913999, 1239412823, 2397907962, 3942897187, 2435381198, 4007365042, 1591831562, 1664232451] -> 1198085477
[3487615865, 4016084043, 1447817513, 2774535999, 1987172957, 3906060658, 3082008686, 88752056, 1947416015, 3376238098, 3503927625, 342228658, 2709452172, 1070052314, 3791872618, 1290870698, 587900606, 1133043554, 671196454, 3876594873, 526665632, 165876551, 3122917378, 4053700531, 1298948490, 1351144611, 563691115, 322287271, 2461185743, 3663527460, 4222266716, 3553092834, 4168116886, 1291668088, 2033147092, 17653398, 3675413239, 2758765766, 2242336270, 734645239] -> 1234710497
[4199109099, 1728109096, 1057011054, 312030739, 490158329, 2571270959, 1337574406, 3037342898, 2943362559, 468588625, 1215641907, 891368463, 3446982561, 146537280, 1406572684, 1996341215, 1239450385, 3239123491, 2654855274, 584040319, 664433665, 3282777560, 3498456462, 398718226, 3318895203, 4109932784, 435092929, 3761442422] -> 1281039914
[330441100, 3682376585, 1548511518, 1012361554, 1641750013, 1347050521, 2746331107, 363031882, 3664742187, 263887825, 3045968855, 4047861721, 4201376344, 2013802400, 43925321, 2057073856, 974221675, 1240944962, 3823005386, 3154676709, 1649841356, 3211264096, 355417272, 2640980835, 2706339938, 987877841, 110633642, 4200784138, 3756125284, 471091914, 3370617977] -> 1307906352
[3242988428, 4255969082, 867271806, 415292052, 3609803438, 416630352, 3232953772, 4269951801, 350204559, 4181264343, 2332795572, 2668659134, 2628956236, 3596517643, 2454368561, 1369266677, 3672701863, 388613580, 1479812495, 2141142524, 2486572053, 2320908196, 393062185, 1938229604, 231136143, 1626064567, 1493467817, 1983339349, 894785483, 44315897, 1514887732, 1864793575, 3953707615, 3492718672, 3522516821, 289358385, 2227856486, 256540739, 4213343606, 200728817, 3396994332, 3845507785, 220892851] -> 1358830177
[3696325595, 95369954, 135918350, 487636311, 825705453, 3049392697, 841126004, 1979734631, 507462131, 1964376824, 3031319264, 3487421046, 2192402845, 3792297163, 3808487536, 1516405605, 664293073, 613658148, 4063050354, 1921745034, 2258497732, 3473698642, 3256102715, 1916456581, 1185919167, 3315712023, 2955859300, 1784025278, 2641317925] -> 1394873382
[2775177776, 3943074566, 1008831348, 423577731, 2936039382, 3419907541, 3346657170, 1767888023, 2549910502, 1510292917, 609091982, 3619041655, 1071140841, 4210891014, 4197129534, 4002247218, 1785145415, 773140313, 850187206, 3695148850, 1699963321, 2029501148, 2273345989, 2045294772, 2490424114, 3670522622, 1903814852, 2845243988, 547217989, 814736327, 1178316093, 3421797242, 583834194, 560861293, 1728122240, 1143281622] -> 1418337751
[3909221229, 1543378013, 3578599386, 1821301593, 382025872, 3090149061, 2799832135, 2969167740, 3214053618, 2459088339, 61851869, 2988154510, 3405155263, 1143312722, 3055626916, 1306722473, 2424970867, 3838250998, 2541260784, 3634562987, 91009990, 228167376, 144739158, 69758376, 1416179539, 175832649, 1058618668, 3141319060, 2603813691, 3448922532, 3563483339, 2187253777, 3939459963, 729053170, 348198400, 2818894106, 4163690148, 4269596985, 1550179869, 2888474224, 977138852, 2267335031, 1039633247, 331897176, 3493431132] -> 1440945260
[548460784, 2008846553, 4095226690, 2537987040, 1412322911, 295388541, 388770296, 2073124976, 4254588769, 2032785043, 3714052855, 653890260, 3378524009, 4169809326, 1850329785, 2009334592, 2701527530, 260935905, 1081271463, 3349408130, 187425716, 588199859, 1037983019, 3586620795, 4254384458, 3345512384, 1424865889, 1577623131, 3897199153, 2727265103, 3204931862, 4089210973, 1909632078, 3588030047, 1946727191, 502364265, 2290334448, 2873594561, 1542446006, 3459132329, 4292608386, 3741690622, 165647068, 1253913368, 1993997790, 2812680991, 2352267270] -> 1500826128
[888893887, 2614777345, 2033163377, 4036989271, 3569896418, 1268962278, 1146226964, 107044610, 2147272927, 3436615686, 1202308143, 1325516848, 2994121867, 973196789, 3793281340, 3099942299, 2472036270, 1798140896, 2858254867, 2204354371, 3472459738, 826142039, 4066377434, 2519409484, 1777413266, 3493671143, 551412865, 886786197, 3882384707, 1172607108, 636563066, 190968362, 3994307050, 3757375918, 2755608252] -> 1566530912
[2820693508, 1716694240, 2268887698, 1296436510, 2916995305, 3041798596, 3096982293, 177546898, 3065170162, 933607211, 102294817, 1801218436, 102569645, 2901869379, 2714886480, 119387632, 656198271, 1388322584, 2775933520, 255861774, 653410879, 121504271, 3607745288, 2230556561, 2594802791, 1189055855, 1111240008, 2530579856, 936965766, 3263165681, 1646076782, 3215192313, 2313499990, 1836078863, 76222274, 3537625615, 3448299995, 1142686967, 2783169043, 1481999457, 407759227] -> 1596242054
[2829936706, 3129475899, 3747369794, 3436426639, 2221019177, 2711897885, 2281503984, 3142203725, 1105679393, 2240453588, 21256724, 1976207648, 2233823367, 3867572431, 883054004, 3828587385, 55294132, 3869553795, 815613304, 1561650320, 1751491302, 3021430621, 3344018026, 1092797427, 2270330908, 872186202, 1096541534, 2148792176, 3302750004, 1221765447, 2805795772, 779878772, 758662454, 4154291008, 1400703216, 2661407119, 3653090591, 674866675, 688479370, 757212805, 2546987102, 3742892714] -> 1598478846
[1350161655, 3410944815, 579310510, 2035583578, 2536805685, 2120035014, 3911683567, 137430281, 676637211, 80424819, 2031627279, 1805522976, 2901778769, 2558787384, 2175054, 1588147737, 1750628274, 1642903038, 2323086809, 204561611, 3017703970, 66172789, 3753895397, 1082808709, 343477515, 3245691790, 2098802152, 2796851615, 3416307802, 1023857834, 1965832789, 412854529, 354175981, 3277463158, 2311727857, 3748028931, 75711999, 605941926, 4268457500, 1591192393, 2493456550, 1285360546, 160198834, 3576865205, 188890618, 1853564214, 4281264410] -> 1682874144
[1759970266, 4134439683, 1532925684, 269299343, 4192017837, 3267142052, 2227585380, 917508171, 2947539107, 1298614074, 3027970270, 3512964090, 78445334, 3939961135, 1550341966, 891964846, 882505655, 314334452, 536698283, 4073297092, 1362911951, 10583051, 4102282272, 39722618, 817646395, 635913246, 3395599638, 114835278, 2721016640, 1301397743, 3359042468, 1967603896, 1842991024, 797964890, 4075738194, 1833629245, 222121931, 3323140076, 3669797521, 2149358182, 3096189598, 4128620833, 1053919363, 3716968416, 1538927892, 3456625069, 3320651259, 2424645618, 3487090498, 1836457156] -> 1757912108
[3206311438, 3995119122, 875115076, 1697246932, 1819127701, 3119338948, 4287411440, 398614242, 2014590172, 1247230330, 4290547991, 2948954546, 3744789096, 2104418209, 185774855, 4253667876, 2202426919, 3397365003, 2934331500, 2095666656, 996668853, 249650538, 3668868008, 1615410768, 492066747, 3451532273, 3886898259, 1151021320, 1782145434, 2431016438, 2907780443, 2152384331, 800661361, 2028554209, 1103300513] -> 1779025760
[1744880977, 2233651387, 56617556, 1115479166, 2611598968, 1306003390, 2910946867, 1496609711, 4077408131, 3512362374, 2281393975, 3418144659, 1773074316, 1601343734, 807592751, 2365582522, 1446242874, 847706414, 2850851126, 414921605, 2617956981, 4205647553, 4063233713, 142946783, 1975643220, 1993142296, 3392343515, 1515671667, 1948071803, 3991728328, 968499177, 2198785340, 1321024334, 3781705466, 3920003634, 727611412, 30865083, 1239101335, 3511359132, 3435471655, 2332994209, 3451243757, 2388153527, 3219135587, 3239646757, 130935018] -> 1815085532
[3742736007, 3013982958, 950712805, 590882231, 2021027712, 1687735825, 2840162788, 236595715, 1966708028, 3189262610, 1430349774, 533579944, 2649611396, 2583295302, 3582250057, 2565346361, 396439695, 4153603028, 3342863641, 209226977, 3673492099, 1470755570, 1265241721, 755285979, 1871568539, 1835865540, 614068679, 1981443993, 570207739, 4057872936, 636526617, 3083893122] -> 1892006865
[2363102448, 2664740190, 3782032362, 2321087205, 3789479744, 439476800, 267092854, 559662253, 3052920007, 1039904017, 882951865, 1185772050, 121779049, 1255320891, 3898061704, 4160716348, 1870139159, 1739210570, 2851269822, 866317206, 559870442, 3322246740, 419503690, 1438071640] -> 1972485478
[3678708758, 283072981, 1128708041, 648928081, 516617525, 2562088844, 2077772312, 454404108, 2773100394, 3731939823, 3956390266, 1273038228, 711119494, 1889950256, 2150587570, 2368988611, 3083613740, 136402153, 3706807002, 1951409673, 646402003, 1965112544, 3799779787, 2727912100, 3934407652, 3190480389, 2893737274, 3503914114, 1242998415, 3673986521, 3585553888, 1356707071, 2892703448, 2503698089, 677538230, 3777556915, 4131625633, 3989648217, 3371399362, 916533795, 438016809, 1888923541, 4018783570, 35576878, 1439895305] -> 2006012423
[4186976930, 1468422130, 2127537262, 3013431126, 1014175853, 619237775, 2251537150, 2635437352, 2529830434, 270079805, 2249885826, 4160741826, 1799997550, 90064691, 1707888518, 4191506978, 1400211336, 4260528976, 1777462871, 3522395605, 3184921911, 1289756682, 1204481339, 2320228865, 1382458891, 2585094069, 1807393027, 904952345, 2418050161, 3944759600, 850396791, 2010841661, 911793010, 2814160212, 3917390566, 1742258451, 312330630, 1509247515, 3622596041, 2381664940, 792997581, 1348701222, 4231392479, 1492858603, 841395446, 1732373831, 2792829070, 1232839054, 4133086979, 1330710519] -> 2023628655
[1447486536, 1589601829, 2711407664, 2671174482, 755815460, 2739822893, 624189525, 3881531582, 2104935742, 3877151275, 4029158122, 3270473853, 2397135808, 541842801, 4159848352, 1265295340, 2924665155, 1697146316, 1323336501, 1887970585, 3957105141, 4080944661, 1260974434, 2538893190, 1418098060, 1087907449, 1555085135, 517760467, 1165667983, 1976195378, 899913113, 3298189181, 2844731428, 2587250768, 419676280, 3669952139, 1008835697, 2109855126, 2204851528] -> 2080799654
[3057502862, 2753037643, 586428454, 875470641, 763920856, 1915854920, 960628797, 3268824212, 155894276, 326435370, 4153187586, 3266725420, 3421441761, 984314678, 134133671, 1571569456, 3290768531, 1270814441, 3360280927, 63041059, 1367587866, 3837387650, 3016828154, 1932299196, 2677431226, 118282642, 4274320011, 2842715068, 3590275349, 3385213492, 3669399717, 23889551, 1990874337, 2065027029] -> 2124973901
[404963327, 970175530, 2315604326, 759401990, 3265128006, 3886300253, 2428903513, 2547895316, 2394147688, 1256335272, 54823458, 1121206884, 1587348808, 1813532729, 475467047, 2240315018, 4228484438, 3836003837, 1713780997, 1021495744, 1667817101, 3431813061, 1741019894, 244489142, 4185223756, 2154392407, 1130398867, 2200660986, 1655353090, 824162463, 269754245, 853115597, 554916755, 3901389184, 3490586038, 2387525212, 3363338561, 2848158299, 1365520662, 65222054, 969608783, 3832404018, 797302386, 220365549, 998915816, 3880644358, 1656707899, 113713704] -> 2200030708
[1182658594, 858230724, 1872357797, 2818651205, 2361035630, 2882362708, 774158555, 1780906106, 1245895866, 1925774739, 1695790856, 1650553385, 3918997115, 1289270838, 1080124671, 1854179057, 4032572199, 3398178415, 2660852575, 2126762197, 2845072225, 3916118969, 2961311910, 3490728772, 2152765282, 925727050, 2046977563, 3481846724, 3016398740, 3170193754, 3947157907, 2318811664, 665856332, 2694492251] -> 2222600201
\$\endgroup\$
2
  • \$\begingroup\$ Do you have a reference implementation which does this in a reasonable time? I know that I've tried reversing MT with the Z3 constraint solver without success. \$\endgroup\$ Nov 27, 2016 at 14:40
  • \$\begingroup\$ @PeterTaylor I don't have a solution myself, though granted I haven't put much effort towards coming up with a solution yet. \$\endgroup\$
    – user45941
    Nov 27, 2016 at 18:29
1
\$\begingroup\$

Implement the Terducodec

In this challenge we'll be implementing a tersum duplicate coder/decoder; aka, a terducodec. This is a reciprocal substitution cipher, so the encoder and the decoder are the same.

Definition

The tersum duplicate of a number x is 2x using base 3 without carries. Alternately phrased, the tersum duplicate of x in base 3 is simply x in base 3 with the 1 and 2 digits swapped.

For example, the tersum duplicate of 47 is 64, because 47=1202b3, and 2101b3 is 64. Note that since this is simply a result of swapping base 3 digits, the tersum duplicate operation is its own inverse.

Terducoding

We code at an octet level, using values in the range 0 to 255 and the tersum duplicate operation. To keep the result in the range 0 to 255 the operation is applied to each of the following subgroups:

  • 0 through 242
  • 243 through 251
  • 252 through 254
  • 255

Given n in the range 0 to 255, let s be the lowest value in the same subgroup as n. Then n can be terducoded as follows:

  • Subtract s from n
  • Calculate the tersum duplicate of this result
  • Add s back to the above

Examples

The value 195 is in group 0 through 242. This group's s value is 0. Thus, we simply take the tersum duplicate of 195=21020b3, which is 12010b3=138.

The value 246 is in group 243 through 251. This group's s value is 243. Thus, we take the tersum duplicate of 246-243=3=10b3, which is 20b3=6, and add s back in to get 249.

The value 252 is in group 252 to 254. This group's s value is 252. Thus, we take the tersum duplicate of 252-252=0=0b3, which is just 0b3=0, and add s back to get 252.

The Challenge

Write a program or function that implements the terducodec. Your program or function should accept as input an ordered sequence of octets, and produce as output a corresponding ordered sequence of terducoded values. The input/output mechanism may use standard input and standard output, arrays, etc; however, your chosen mechanism must be able to represent any sequence of octets where each octet has the full possible range.

This is code golf. Standard loopholes disallowed. The smallest terducodec in bytes wins.

Test Case

A single test case doubles as a list of all possible encodings. Here, the decimal representation is used for each octet.

  0   2   1   6   8   7   3   5   4  18  20  19  24  26  25  21
 23  22   9  11  10  15  17  16  12  14  13  54  56  55  60  62
 61  57  59  58  72  74  73  78  80  79  75  77  76  63  65  64
 69  71  70  66  68  67  27  29  28  33  35  34  30  32  31  45
 47  46  51  53  52  48  50  49  36  38  37  42  44  43  39  41
 40 162 164 163 168 170 169 165 167 166 180 182 181 186 188 187
183 185 184 171 173 172 177 179 178 174 176 175 216 218 217 222
224 223 219 221 220 234 236 235 240 242 241 237 239 238 225 227
226 231 233 232 228 230 229 189 191 190 195 197 196 192 194 193
207 209 208 213 215 214 210 212 211 198 200 199 204 206 205 201
203 202  81  83  82  87  89  88  84  86  85  99 101 100 105 107
106 102 104 103  90  92  91  96  98  97  93  95  94 135 137 136
141 143 142 138 140 139 153 155 154 159 161 160 156 158 157 144
146 145 150 152 151 147 149 148 108 110 109 114 116 115 111 113
112 126 128 127 132 134 133 129 131 130 117 119 118 123 125 124
120 122 121 243 245 244 249 251 250 246 248 247 252 254 253 255
 ->
  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
 16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31
 32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47
 48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63
 64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79
 80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95
 96  97  98  99 100 101 102 103 104 105 106 107 108 109 110 111
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

\$\endgroup\$
1
56 57
58
59 60
155

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .