485
\$\begingroup\$

What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

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

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

| |
\$\endgroup\$

2927 Answers 2927

1
86 87
88
89 90
98
0
\$\begingroup\$

Infinite Mirrors Quine

This challenge is to create a program that prints out code that prints the original. Basically, this program should take an input, check if it's A, and if so, run section A. Otherwise, if it's B, run section B. Finally, if it's neither, print nothing. Section A should print the code in section B, and section B should print the code in section A. Section A's code and section b's code should not be identical. Shortest code wins!

| |
\$\endgroup\$
0
\$\begingroup\$

Crazy Blazin' DOM Injection

I was instructed to post this code golf challenge here for recommendations on how to modify the challenge.

I'd like to tag it.

fastest-code grid and browser , but I don't know how to do that here.

Code golf challenge listed below.

Introduction

This problem is a challenge that has to do with DOM manipulation at scale and overcoming some issues that may be inherent in dealing with the DOM.

  • This challenge is interesting because limitations push us to think through things differently and lean on the strengths of languages different than what we usually use.
  • I created this challenge myself based on a real world problem I ran into myself (details can be provided if needed). If this challenge has any relation to a differently know problem, those similarities are coincidental.

This challenge will be scored based on fastest execution and fastest algorithm. A multiplier will be given for completing the challege at easy, medium, and hard difficulties.

Challenge

You must render one of the challenge levels in a web browser:

Through any means available to you interacting through a web browser in code you need to complete the following:

  1. Get each table displayed and add a class table-n to each table where n is a zero based index of order of the table on the screen. If a table is nested within a table the parent would be N and the child would be N+1 with the next table being N+2.
  2. Get each row displayed in each table and add a class of table-n-row-r where r is a zero based index of rows in the table represented by table-n.
  3. Get each cell displayed in each table and add a class of table-n-row-r-cell-c where c is a zero based index of cells in a row represented by table-n-row-r.

At the end of the challenge the web page should still be able to be interacted through in the browser, and a call to document.getElementsByClassName('table-n-row-r-cell-c'); should return one and only one cell from the DOM.

Any method available to you as valid as long as:

  1. Access to one of the difficulty levels has been done through a web browser
  2. The URL of the browser and the page displayed doesn't change
  3. A call to document.getElementsByClassName('table-n-row-r-cell-c'); returns only one element

Output Examples

For this example we're using the easy level as input.

The abbreviated output in the DOM should be.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Code Golf Challenge</title>
</head>
<body>
    <table class="table-0">
        <thead>
            <tr class="table-0-row-0">
                <th class="table-0-row-0-cell-0">1</th>
                ...
            </tr>
        </thead>
        <tbody>
            <tr class="table-0-row-1">
                <td class="table-0-row-1-cell-0">11</td>
                <td class="table-0-row-1-cell-1">12</td>
                ...
            </tr>
            ...
    </table>
</body>
</html>

There are only <td> and <th> elements used as cell elements for the challenge.

As long as document.getElementsByClassName('table-n-row-r-cell-c'); returns an element with this class. We're good to go.

Qualifying Entries

All entries that qualify need to have an execution speed of under 40 seconds for any difficulty level.

Timing starts when your algorithm starts, but after the page has loaded completely as all elements must be available (the browser spinner has stopped spinning).

Calculate the runtime for your method by calling performance.now() before and and after your injection method, and subtracting the first from the second as in the example below.

let t0 = performance.now();
doSomething()   // <---- The function you're measuring time for 
let t1 = performance.now();
let totalTime = t1 - t0;

The medium and hard difficulty levels will have their execution time multiplied by 0.50 and 0.25 respectively. None the less, an execution time of less than 40 seconds is needed to qualify. So if the execution time on the medium difficulty was 41 seconds before the multiplier, it does not qualify.

Winner

The winner will be determined by the shortest execution time for dynamic injection of these classes and where document.getElementsByClassName('table-n-row-r-cell-c'); can still be executed against the browser console and return an element where n, r, and c are replaced with indexes.

| |
\$\endgroup\$
  • \$\begingroup\$ Do you mean that all entries should be written as a JS function so that it can be run inside the browser console? Which browser(s) will you be using to time it (since different browsers may have different support of JS features and the engine optimized in different ways)? \$\endgroup\$ – Bubbler Jul 20 at 2:15
  • 1
    \$\begingroup\$ "scored based on fastest execution and fastest algorithm" is ambiguous, because fastest execution means that a constant factor in the algorithm is important, while fastest algorithm is not. I think you mean simply "fastest execution", since it seems hard to use a big-O notation in this task (should it be a function of table size or entire document size?). \$\endgroup\$ – Bubbler Jul 20 at 2:18
  • \$\begingroup\$ All entries should be written as a JS function (I think that's the only way to achieve it). However, if there are other ways to achieve this they are welcome, but it still needs to be an active webpage pulled from the internet. So, pulling via wget or curl and manipulating it locally in something like jelly is out of the question unless Jelly can interact with the browser. We can standardize on chrome 83.0.1.x for the web browser, so that it's exactly the same for all. \$\endgroup\$ – Dodzi Dzakuma Jul 20 at 2:18
  • \$\begingroup\$ It should only be fastest execution then. Let's go with that. \$\endgroup\$ – Dodzi Dzakuma Jul 20 at 2:19
  • \$\begingroup\$ Also, if a submission works for all of easy/medium/hard, how is it scored? I guess the minimum of (easy time), (medium time / 2), (hard time / 4)? \$\endgroup\$ – Bubbler Jul 20 at 2:23
  • \$\begingroup\$ If a submission works for all level (qualifies at all levels) it gets scored at the hardest level it qualifies for. \$\endgroup\$ – Dodzi Dzakuma Jul 20 at 2:24
  • \$\begingroup\$ That sounds like unnecessarily penalizing possibly good submissions because it might run blazing fast on easy but more than 4x slower on hard, giving it a worse score. \$\endgroup\$ – Bubbler Jul 20 at 2:26
  • \$\begingroup\$ I can agree with that. How do you suggest we even that out? \$\endgroup\$ – Dodzi Dzakuma Jul 20 at 2:27
  • \$\begingroup\$ Personally, I think it is better to do away with the different difficulty levels. They aren't exactly the same as bonuses in code golf but most of the arguments for why we don't like bonuses apply to these difficulties, too. \$\endgroup\$ – FryAmTheEggman Jul 20 at 2:43
  • 1
    \$\begingroup\$ I think this will work: "The submission that handles the highest difficulty within 40 seconds wins, ties broken by the time taken to complete for that test case." If the first part of the sentence is confusing, I mean "a submission that handles hard is better than one that can't". \$\endgroup\$ – Bubbler Jul 20 at 2:45
  • \$\begingroup\$ I'll get rid of the difficulty levels. \$\endgroup\$ – Dodzi Dzakuma Jul 20 at 2:45
  • \$\begingroup\$ Actually, Bubbler, what you said makes sense. I'll state it like you said and get rid of the bonus. \$\endgroup\$ – Dodzi Dzakuma Jul 20 at 2:48
  • \$\begingroup\$ Still getting downvotes on the challenge. I don't know the reason why. Implemented the changes we discussed, but I guess it still doesn't meet standards? (^-^;) \$\endgroup\$ – Dodzi Dzakuma Jul 20 at 11:56
0
\$\begingroup\$

How wide is this string?

Given a unicode string in any standard encoding of choice, determine how many columns wide it is.

To keep this challenge relatively simple, use the following rules for character widths:

  • Tab characters align to the nearest multiple-of-8 column
  • CJK characters are 2 columns wide.
    • For the purposes of this challenge, you may assume all characters in Unicode Planes 2 and 3 (U+20000-3FFFF), plus codepoints U+3400-9FFF are CJK characters.
    • CJK characters outside these ranges may be treated as either 1 or 2 columns wide.
  • Combining diacritics (U+0300-036F), control characters (U+00-1F, U+7F-9F), and the zero-width space (U+200B) are all 0 columns wide.
    • All other officially zero-width characters may be treated as either 1 or 0 columns wide.
  • You may assume that there are no newlines or carriage returns.
  • You do not need to handle escape sequences.
  • You may assume all other characters are 1 column wide.
    • For any character the standard says has a specific width, you may use that width instead.

Shortest code wins.


| |
\$\endgroup\$
0
\$\begingroup\$

Tumbling 2x2 in a Matrix

Challenge:

Input: A rectangular integer matrix that's at least 2x2 in size. Output: A 2D integer array, of the result after the top-left 2x2 block has tumbled down.

For example: Let's say we have the following 3x5 matrix as input:

[[ 4, 7,12],
 [11, 2, 5],
 [ 7, 3,15],
 [21,10, 1],
 [12, 6, 6]]

The 2x2 block is [[4,7],[11,2]], which will act as if it was tumbling down from a stairs (in a top-left to bottom-right direction). Here this process step-by-step:

[[ 4, 7,  ],
 [11, 2,  ],
 [--,  ,  ],
 [  ,  ,  ],
 [  ,  ,  ]]

[[  ,  , 4],
 [  ,11, 7],
 [--, 2,  ],
 [  ,  ,  ],
 [  ,  ,  ]]

[[  ,  ,  ],
 [  ,11, 4],
 [--, 2, 7],
 [  ,--,  ],
 [  ,  ,  ]]

[[  ,  ,  ],
 [  ,  ,  ,11],
 [--,  , 2, 4],
 [  ,--, 7],
 [  ,  ,  ]]

[[  ,  ,  ],
 [  ,  ,  ,  ],
 [--,  , 2,11],
 [  ,--, 7, 4],
 [  ,  ,--]]

[[  ,  ,  ],
 [  ,  ,  ,  ],
 [--,  ,  ,  , 2],
 [  ,--,  , 7,11],
 [  ,  ,--, 4]]

[[  ,  ,  ],
 [  ,  ,  ,  ],
 [--,  ,  ,  ,  ],
 [  ,--,  , 7, 2],
 [  ,  ,--, 4,11]]

Doing so, it will add it's values to the other cells in its path. So here is the same step-by-step process with the other numbers added in the cells:

[[ 4, 7,12],
 [11, 2, 5],
 [ 7, 3,15],
 [21,10, 1],
 [12, 6, 6]]

[[ 4, 7,16],
 [11,13,12],
 [ 7, 5,15],
 [21,10, 1],
 [12, 6, 6]]

[[ 4, 7,16],
 [11,13,16],  // Note that the 13 and 5 remain the same, because the cells of the tumbling
 [ 7, 5,22],  // block haven't moved from the previous to this step
 [21,10, 1],
 [12, 6, 6]]

[[ 4, 7,16],
 [11,13,16,11],
 [ 7, 5,24, 4],
 [21,10, 8],
 [12, 6, 6]]

[[ 4, 7,16],
 [11,13,16,11],
 [ 7, 5,24,15],  // Note that the 24 and 8 remain the same, because the cells of the tumbling
 [21,10, 8, 4],  // block haven't moved from the previous to this step
 [12, 6, 6]]

[[ 4, 7,16],
 [11,13,16,11],
 [ 7, 5,24,15, 2],
 [21,10, 8,11,11],
 [12, 6, 6, 4]]

[[ 4, 7,16],
 [11,13,16,11],
 [ 7, 5,24,15, 2],
 [21,10, 8,11,13],  // Note that the 11 and 4 remain the same, because the cells of the tumbling
 [12, 6, 6, 4,11]]  // block haven't moved from the previous to this step

Challenge rules:

  • I/O is flexible. You may take the input as integer-matrix, integer list with loose dimension-inputs, as a list of strings, etc. Output can modify the original input, return a new matrix, print space/newline delimiter to STDOUT, etc.
  • You may optionally take the dimensions as additional input.

General rules:

  • This is , so shortest answer in bytes wins.
    Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
  • Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
  • Default Loopholes are forbidden.
  • If possible, please add a link with a test for your code (i.e. TIO).
  • Also, adding an explanation for your answer is highly recommended.

Test case:

Input:
[[ 4, 7,12],
 [11, 2, 5],
 [ 7, 3,15],
 [21,10, 1],
 [12, 6, 6]]
Output:
[[ 4, 7,16],
 [11,13,16,11],
 [ 7, 5,24,15, 2],
 [21,10, 8,11,13],
 [12, 6, 6, 4,11]]

TODO: More to come.


Sandbox questions:

I might change the tumbling process a bit later on, since I'm not too happy about the current one. I still want the tumbling 2x2 down the matrix, but I might make the way the other values changes a bit different. This is just an initial idea.

  • Any missing tags?
  • Any missing rules?
  • Any suggestions on how to change the output without changing the core part of the tumbling top-left 2x2 block?
  • Any suggested test cases?
| |
\$\endgroup\$
0
\$\begingroup\$

\$d*n\$ dimensional word matrices [WIP]

Given two positive integers \$n\$ and \$d\$, and a list of words \$a\$, produce a \$d\$-dimensional matrix \$m\$ with each dimension having length \$n\$, filled with letters, that contains the words from \$a\$ placed such that they form a directly adjacent contiguous path through the dimensions.

For example, given \$d = 1\$, \$n = 3\$ and \$a = \$['cat'] output one of:

cat

or

tac

Given \$d = 2\$, \$n = 3\$ and \$a = \$['cat', 'hat', 'mat'] output something similar to:

cat
hat
mat

Given \$d = 3\$, \$n = 3\$ and \$a = \$['low', 'complexity'] output something similar to:

coq
igw
typ

kmc
xeo
buf

kpr
dll
scm

or, if it's easier to visualise in an array structure:

[
  [
    ['c', 'o', 'q'],
    ['i', 'g', 'w'],
    ['t', 'y', 'p'],
  ],
  [
    ['k', 'm', 'c'],
    ['x', 'e', 'o'],
    ['b', 'u', 'f'],
  ],
  [
    ['k', 'p', 'r'],
    ['d', 'l', 'l'],
    ['s', 'c', 'm'],
  ],
]

Which contains low at nested indices \$m\$[2][1][2], \$m\$[1][1][2], \$m\$[0][1][2] and complexity at \$m\$[0][0][0], \$m\$[0][0][1], \$m\$[1][0][1], \$m\$[2][0][1], \$m\$[2][1][1], \$m\$[1][1][1], \$m\$[1][1][0], \$m\$[0][1][0], \$m\$[0][2][0], \$m\$[0][2][1].

I'd like to add some more complicated examples beyond three dimensions here.

Test Cases

TODO

Rules

  • Unused spaces should be filled with randomly selected letters.
  • There will always be enough space in the dimensions provided to allow the words to be added without re-using letters.
  • There is no requirement to ensure the words don't also appear elsewhere in the grid, so for example if the filler letters happen to spell one of the provided words, that is acceptable.

Questions for meta

  • This seems fun to me, any thoughts?
  • Is it too easy/hard?
  • Any other tags that are relevant?
  • As a follow up, I'd like to have a nested matrix provided and have programs solve it - but that might be better as a fastest-code challenge - is this a reasonable precursor?
| |
\$\endgroup\$
  • \$\begingroup\$ Is d^n large enough to contain all the words without sharing letters? \$\endgroup\$ – Bubbler Jul 23 at 8:18
  • \$\begingroup\$ Yeah, you won't have to be concerned with that, I'll add that to the rules. \$\endgroup\$ – Dom Hastings Jul 23 at 8:21
0
\$\begingroup\$

Trapping a Jogger

A person starts jogging to the right from his house on a busy street.

t=0
0 1 2 3 4 5 6 7 8 9 A B C
⌂ - - - - G - - G - - - G
>

He travels 1 hectometer every minute, so he is 11 hectometers away from his house after 11 minutes:

t=11
0 1 2 3 4 5 6 7 8 9 A B C
⌂ - - - - R - - R - - - G
                      >

Since this is a busy street, there are walking signals that occasionally turn red. In this example, the signals at 5, 8, and 12 units from home alternate colors every 2, 10, and 4 minutes (this would not be a fun road to drive on). The signals are red (signal stop ✋) for the same duration that they are green (signal go 🏃).

Our jogger doesn't want to wait long, so he instantly turns around when he reaches a stoplight that is red, even if it will turn green within the next minute.

t=12
0 1 2 3 4 5 6 7 8 9 A B C
⌂ - - - - G - - R - - - R
                        >
t=12.001
0 1 2 3 4 5 6 7 8 9 A B C
⌂ - - - - G - - R - - - R
                        <
t=13
0 1 2 3 4 5 6 7 8 9 A B C
⌂ - - - - G - - R - - - R
                      <

This can cause the jogger to reverse direction again, making for a potentially long outing.

t=16
0 1 2 3 4 5 6 7 8 9 A B C
⌂ - - - - G - - R - - - G
                <      
t=16.001
0 1 2 3 4 5 6 7 8 9 A B C
⌂ - - - - G - - R - - - G
                >      

View the rest of the sequence using a visualizer.

Task

Given the cycle intervals and positions of a list of streetlights, determine the time until the jogger returns to his house (at distance 0) or runs to the right of the rightmost streetlight.

The streetlights at time t=0 will all have just turned green.

The n cycle intervals shall all be integers at least 2. The n positions of the streetlights may be taken as either (sorted) absolute distances from home or the distance from that streetlight to the previous. In the example, this would be either [5,8,12] or [5,3,4].

Example cases

positions
intervals
output

5,8,12
2,10,4
38

10
20
11

10
6
20

2,8
8,6
40

2,8
7,6
16

1,2,3,4,5,6
6,5,4,3,2,1
16
```
| |
\$\endgroup\$
0
\$\begingroup\$

Is this chess board configuration forkable?

A fork in chess is when a piece attack at the same time two or more pieces. It is an extremely used tactic where your aim is to get free material or to get a better position in the board.

In this golf challenge, given a chess board configuration, your program should output at which coordinate any of the following pieces (Queen, rook, bishop, knight and pawn) will result in a fork.

Example

Consider the board configuration below:

enter image description here

For this particular configuration, all of the pieces are able to fork:

Queen and bishop: d4

Pawn: d6

Rook: d5

Knight: d3

There are obviously other placements that would result in a fork, but you are only required to output one for each piece (if there is indeed a fork possible).

Meta questions

This is only a sketch, a lot will be improved if this turns out to be an interesting challenge.

  1. Is there a similar challenge?
  2. I need some recommendations about the input/output format.
  3. Should I take into consideration all forks or only those that will not result in the player forking losing the piece? i.e.: In the example above, the rook at b5 will be taken by the white rook so in this scenario this would not be a valid fork (in fact, in this configuration only the knight fork would be possible).
  4. I am not using the king as a forkable piece because of possible impossible moves due to checks. Should I?
  5. For pawns, in the example above the only possible fork would be at d6 because of the standard chess configuration. Should the challenge allow for (in this case) black pawns to fork at d4?
  6. Should I make a distiction between dark and light squared bishops?
| |
\$\endgroup\$
  • \$\begingroup\$ (general comment) The "hard code all possible moves of all pieces" are not-very-interesting, but otherwise the background is relevant enough. \$\endgroup\$ – user202729 Jul 29 at 1:51
  • \$\begingroup\$ (answers) 1. I can't find one. 2. Perhaps "the classic position notation or a list of 2 integers [row, col], 0 or 1 indexing". 3. It's up to you, the latter will make the challenge more complex. 4. Same as above. 5. No. 6. ... no, that can be inferred from the output. \$\endgroup\$ – user202729 Jul 29 at 1:55
  • \$\begingroup\$ 3. I'm not aware of anyone saying that a move doesn't count as a fork if the forking unit can be captured. Here, Tim Krabbé lists some misconceptions some people have about what a fork is, and he adds a couple of his own, but he doesn't list the idea that the forking unit cannot be en prise. \$\endgroup\$ – Rosie F Aug 1 at 8:05
0
\$\begingroup\$

International "Hello, World!" (WIP)

(Please note the special scoring for this challenge)

This code-golf question has over 900 answers and all of them print "Hello, world!" in English! If we can use hundreds of different programming languages to print that message, why can't we use hundreds of different natural languages to express that message?

Task & scoring

Your task is to beat the answers of the Hello, world! challenge ("HW" challenge from now on) in different natural languages, as determined by the length ratio of the English string "Hello, world!" and the string in the natural language you pick. For example, I could pick Portuguese, hence I will have to print "Olá, mundo!" which has a length ratio of 11/13.

  • if your natural language has capitalization, you must respect the original capitalization.
  • if your natural language has punctuation, you must respect the original punctuation.

Then you pick the programming language you are going to write your code in. For example, I could pick Python. And you write your program. My program could be print("Olá, mundo!"), with a standard code-golf score of 20.

You then look for the best submission in the HW challenge with the same programming language you chose, let's say it has score S. (We probably need a leaderboard for challenge HW to make this step easier.) My score would then be (20/S)/(11/13).

Does this make any sense? Any preliminary feedback?

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ It's hard to define whether the grammar of the output is correct in the chosen language, especially for those who don't know the language. \$\endgroup\$ – user92069 Jul 29 at 9:46
  • \$\begingroup\$ @user92069 why do I need to define if the grammar is correct? "Hello, world!" doesn't look grammatically very correct either. \$\endgroup\$ – RGS Jul 29 at 22:36
0
\$\begingroup\$

Extract an integer from another

This is a somewhat interesting problem I ran into while nanboxing: given two integers, compute their bitwise-AND and concatenate the resulting "substrings" into a new integer.

More precisely: you are provided two integers as input — an input integer and a bitmask. As output, you should produce the bitwise-AND of the two such that, given a mask with \$n\$ set bits, the corresponding bits from the input are grouped together in the first \$n\$ bits of the resulting integer.

The following pseudocode is one way to implement the function:

-- x and mask are lists of booleans
function (x, mask)
  local result=list();
  for i=1, min(x.length, mask.length) do
    if mask[i] then
      result.append(x[i]);
    end
  end
  return result;
end

Example inputs and outputs

// In binary:
// f(x, mask) == result
f(1011, 1111) == 1011 // Select entire number
f(1010, 1010) == 11   // Select bits 1 and 3, and concatenate them
f(11001100, 01100110) == 1010 // Concatenate substrings [1:2] and [5:6]
f(11111111, 10101010) == 1111 // Concatenate bits at odd indices.

// 16-bit variants in hexadecimal:
f(BEEF, 1111) == 9
f(DEAD, 8888) == F 
f(1337, FF00) == 13
f(CODE, 7777) == 82E

// Two 64-bit variants (in hex):
f(400921FB54442D18, CODE601F15DABE57) == 111DE42C8
f(FFFE0000004010CC, 8003000000000000) == 6

Specific rules

  • Standard loopholes, default IO, etc. apply where not overridden.
  • Input and output values must fulfill \$x \in \{b_{set}, b_{unset}\}^{n}\$ for some \$b_{set} \neq b_{unset}, n \in \mathbb{N}_{\geq 16}\$ of your choice. In other words:
    • You must support integers of at least 16 bits in your representation, but you may otherwise arbitrarily constrain their size - i.e. to 32-bit integers. You may also accept integers of any length through lists, arrays, strings, etc.
    • The "set" and "unset" values do not need to be of the same type or length, but they must be constant and distinct.
    • Most "linear" representations for integers are valid: integers, vectors, arrays, strings, etc.
  • This is , so the shortest answer in bytes wins.
  • Have fun!
| |
\$\endgroup\$
  • \$\begingroup\$ Is this the PEXT BMI2 instruction? (also, possible duplicate: codegolf.stackexchange.com/q/37167) \$\endgroup\$ – my pronoun is monicareinstate Jul 30 at 13:00
  • \$\begingroup\$ @mypronounismonicareinstate After reading the referenced challenge I think this is indeed a duplicate of that. The required algorithms are identical and other requirements seem to not affect this too much. \$\endgroup\$ – Shieru Asakoto Aug 3 at 4:07
  • \$\begingroup\$ @mypronounismonicareinstate I've given it a read, and it definitely is the same challenge, bar minor cosmetic differences. Of course, the search did not find it when I tried searching for it... \$\endgroup\$ – CompilerPotato Aug 3 at 11:46
0
\$\begingroup\$

Make yourself a COBOL BASIC for great evil

Task: Make an internal or external DSL that looks as much like a subset of BASIC as possible (the subset's defined below). You can use other people's libraries if you want. Using that DSL, you have to calculate and print the first 20 Fibonacci numbers. (Note for meta: I'm not sure about the Fibonacci numbers part. A different task would do)

Rules:

  • Don't just make a shell script calling a BASIC compiler
  • Each statement must begin with a line number, just like BASIC
  • The DSL should have variables, assigned like LET X = 100. The LET can be optional if you want.
  • There should be if-statements that look like IF condition THEN statement
  • There should be a PRINT keyword, usable with variables and string literals. An example would be PRINT "foo", X, which prints the value of "foo" and then X, or PRINT "foo";X, which prints "foo" and then X without continuing to the next line.
  • There should be a GOTO keyword, so you can beautiful code like 270 GOTO 40 without having to write those god-awful loops.
  • (Optional) Every program ends in an END command. It's optional because subroutines aren't included.
  • There should be basic arithmetic operations like *, +, -, \ included; and relational operators like >, <, = (== in some languages), and <> (!= in some languages).

(Question for meta: Is this subset specific enough?)

Stuff you don't necessarily have to do:

  • Implement subroutines.
  • Worry about line numbers not being in the right order. You can assume programmers are responsible enough to put line 20 after line 10.
  • Implement loops of any kind. GOTO is all you will ever need.
  • Add comments (REM)
  • Add a HOME, CLS, or TEXT command. Assume they've been set already.
  • Implement lists and stuff

Scoring (I'm not sure about this):

  • Shortest program (in the BASIC-like DSL) wins ???
  • Or maybe compare that Fibonacci number generating program to this one (with Levenshtein distances)? (may require corrections and/or polishing):
10 LET A = 1
20 LET B = 1
21 PRINT A
22 PRINT B
30 LET I = 1
50 LET S = A + B
60 PRINT S
70 LET A = B
80 LET B = S
90 LET I = I + 1
100 IF I < 20 THEN GOTO 50
110 END
| |
\$\endgroup\$
  • 3
    \$\begingroup\$ looks as much like COBOL as possible is too subjective for the goal of the challenge. A better challenge would be "write a subset of COBOL" with clear syntax and semantics. \$\endgroup\$ – Bubbler Jul 28 at 2:46
  • 1
    \$\begingroup\$ I guess you added the Levenshtein distance to measure the similarity, but there will be infinitely many valid programs that fulfill a task, both in COBOL and the DSL (especially if the DSL is Turing-complete). How would you check if there exists some pair of programs that are close enough? \$\endgroup\$ – Bubbler Jul 28 at 2:50
  • \$\begingroup\$ Popularity-contest isn't really suitable on this site. \$\endgroup\$ – user202729 Jul 28 at 14:07
  • \$\begingroup\$ @Bubbler How about now? I used BASIC instead of COBOL because it seems to have less keywords and easier syntax. \$\endgroup\$ – user Jul 29 at 15:10
0
\$\begingroup\$

Write an ASPIF (clasp's ASP input format) program to find a maximum cap set (https://en.wikipedia.org/wiki/Cap_set) for 4 dimensions.

Share the code you used to generate the ASPIF rather than ASPIF itself. This may be an ASP program.

Winner is smallest word-count (according to wc) in ASPIF format. For ASP, you can get this by running something like:

clingo capset.asp --mode=gringo | grep -v "\(^1 0 1 [0-9]\+ 0 0$\)\|\(^4\)" | wc -w

(note the grep is for excluding unary rules and #show directives neither of which are necessary for solving. The output of this is still a valid clasp program)

I have an example for four dimensions (but I have a better one I won't share right away because I'm curious to see what other people get).

feature(number, (one; two; three)).
feature(shading, (solid; empty; striped)).
feature(color, (red; green; purple)).
feature(shape, (oval; diamond; squiggly)).
dimension(D) :- feature(D, _).
card(c(N,F,C,S)) :-
    feature(number,N); feature(shading,F); feature(color,C); feature(shape,S).
property(c(N,F,C,S),number,N) :- card(c(N,F,C,S)).
property(c(N,F,C,S),shading,F) :- card(c(N,F,C,S)).
property(c(N,F,C,S),color,C) :- card(c(N,F,C,S)).
property(c(N,F,C,S),shape,S) :- card(c(N,F,C,S)).

{in_capset(X) : card(X)}.
:~ in_capset(X).[-1,X]

settable(D, A, B, C) :-
    feature(D, A); feature(D, B); feature(D, C); A != B; A != C; B != C.
settable(D, A, A, A) :- feature(D, A).

:- in_capset(X); in_capset(Y); in_capset(Z);
    settable(D, A, B, C) :
        dimension(D), property(X, D, A), property(Y, D, B), property(Z, D, C);
    X < Y; Y < Z.

#show in_capset/1.

This grounds to an ASPIF program with 9296 "words"

| |
\$\endgroup\$
  • \$\begingroup\$ 4D cap set is already known and has a pattern which was found in a challenge of mine, so it might be too trivial. Why not ask to take n as input and solve for n dimensions (without time and memory limit)? \$\endgroup\$ – Bubbler Aug 7 at 3:32
  • 1
    \$\begingroup\$ Also, most people here are not familiar with ASP or ASPIF. It would be helpful if you include relevant links, so we can do some research before tackling the challenge. \$\endgroup\$ – Bubbler Aug 7 at 3:34
0
\$\begingroup\$

Simulate simple Bloons Tower Defense!

For those who are unaware of this legendary series of video games, here is a link.

The task

You are going to be given an integer number and type of bloon wave and two integers describing the damage and pierce (max amount of bloons you can damage in one attack) of each attack. Your task is to output in how many attacks can you destroy the bloon wave.

Bloon types

For simplicity, there will be no special properties like fortified, regrow, camo e.t.c. White bloons will also not be present as, without special properties, they are the same as black bloons

Name - health - what it pops into
BAD   - 20000 - 3x DDT and 2x ZOMG
ZOMG - 4000  - 4x BFB
BFB   - 700   - 4x MOAB
MOAB - 200   - 4x Ceramic
DDT   - 350   - 6x Ceramic
Ceramic - 60    - 1x Rainbow
Rainbow - 1     - 2x Zebra
Zebra   - 1     - 2x Black
Black   - 1     - 2x Pink
Pink    - 1     - 1x Yellow
Yellow  - 1     - 1x Green
Green   - 1     - 1x Blue
Blue    - 1     - 1x Red
Red     - 1     - Nothing!

I/O

Input: A string describing the type of bloon, and three integers: the amount of bloons in the wave, attack damage and attack pierce

Output: An integer describing how many attacks are needed for destroying the whole wave.

Examples

Note: If there is not enough pierce n to attack the whole wave, then only the first n bloons are attacked

Input: Rainbow 3 2 10
Starting: 3x Rainbow
Attack 1: 12x Black
2: 20x Yellow 2x Black
3: 10x Blue 10x Yellow 2x Black
4: 10x Yellow 2x Black
5: 10x Blue 2x Black
6: 2x Black
7: 4x Yellow
8: 4x Blue
9: Done!
Output: 9

This is the 4/0/x Sniper Monkey:

Input: BFB 1 30 1
1: BFB(670)
2: BFB(640)
...
13: BFB(10)
14: 4x MOAB(180)
15: 1x MOAB(150) 3x MOAB(180)
...
19: 1x MOAB(30) 3x MOAB(180)
20: 4x Ceramic(60) 3x MOAB(180)
21: 1x Ceramic(30) 3x Ceramic(60) 3x MOAB(180)
22: 3x Ceramic(60) 3x MOAB(180)
...
27: 1x Ceramic(30) 3x MOAB(180)
28: 3x MOAB(180)
...
69: 1x Ceramic(30)
70: Done!

This is codegolf, so lowest byte-count wins

| |
New contributor
Dion is a new contributor to this site. Take care in asking for clarification, commenting, and answering. Check out our Code of Conduct.
\$\endgroup\$
  • 3
    \$\begingroup\$ This is extremely complicated. I feel like this will be in unanswered for a while. \$\endgroup\$ – Razetime Aug 10 at 17:04
  • \$\begingroup\$ In the second example, how is ceramic destroyed without giving out any lower class bloons? \$\endgroup\$ – Bubbler Aug 11 at 0:31
0
\$\begingroup\$

Secret ">" Stacking Challenge

Background

Tetris Grand Master 3 has a hidden grading system based on the shape of the stack at the end of the game, which is called Secret ">" Stacking Challenge. It consists of entirely filling the lowest rows except for the zigzag pattern which starts at the left bottom cell and spans the entire width:

#
.#########
#.########
##.#######
###.######
####.#####
#####.####
######.###
#######.##
########.#
#########.
########.#
#######.##
######.###
#####.####
####.#####
###.######
##.#######
#.########
.#########

The board is graded by how many lines follow this exact pattern from the bottom line. Note that the topmost hole in the pattern must be blocked by an extra piece of block. If you consider the #s and .s as the mandatory pattern (blanks can be anything), you can get the score of 19 only if the exact pattern above is matched from the bottom line. Analogously, if the board matches this pattern

   #
###.######
##.#######
#.########
.#########

but not

    #
####.#####
###.######
##.#######
#.########
.#########

then the score is 4.

For this challenge, consider a board of arbitrary size (other than 20 cells high and 10 cells wide). We can grade the board for the same pattern: for example, if the board has width 4, this is the pattern for score 3:

  #
##.#
#.##
.###

and this is the pattern for score 10:

   #
###.
##.#
#.##
.###
#.##
##.#
###.
##.#
#.##
.###

Challenge

Given the final state of the Tetris board of arbitrary size, grade the board using the system above.

You can take the board using any sensible format for a rectangular matrix, where every cell contains one of two distinct values (for empty and filled respectively). You can assume the grid is a valid Tetris board (no row is entirely filled).

Standard rules apply. The shortest code in bytes wins.

Test cases

Coming soon.


Meta

  • Is the task clear enough?
| |
\$\endgroup\$
0
\$\begingroup\$

[PuyoPuyo] How long is my combo?

Context:

PuyoPuyo is a puzzle game where you and your opponent pile up colored slimes (called puyo) in a vertical (13*6 cells) grid. A puyo is one-cell big, but they come as pairs in the screen. Puyo pairs fall from the top to the bottom of the grid, and you can move and rotate them the Tetris way. The list of possible puyo pairs is the cartesian product of {'red','blue','green','yellow'} with itself. The pair sequence for a game is randomly generated for both players at the start of a round, and will be the same for both of them.

If four puyo (or more) of the same color are next to each other (in line, in square, Z-, S-, T-, J- or L-shaped), they disappear, awarding you points and making all the above puyo to fall. If when those puyo fall, they make another group of four (or more) they will disappear too, awarding you with more points than the first group: it is called a two-hit combo.

When a combo stops, whatever its length (1-hit or more), you will send damage to your opponent. The bigger the combo, the more damage is sent. Those damage are called ojama puyo, grey slimes that disappear only when a group disappears next to it. If your third column from the left is filled before your opponent's is, you lose. So to kill your opponent, you must manage to fill its screen before they fill yours.

Challenge:

With a given sequence of puyo pairs associated with their drop locations, output the length of the combo that has been made by this player. Shortest code in any language wins.

Input:

List of puyo pairs and their drop locations:

  • 'r1b1r1r2y2r3...'
  • '001000013102...'
  • [('red','1','blue','1'),('red','1','red','2'),('yellow','2','red','3'),...]
  • any sensible way you want, provided you detail how it works

Details:

  • You can assume that this list will always have an even length.
  • You can assume this list is correct, you will never have any "column number" outside of [1;6] (or [0;5], if 0-indexed) nor a puyo of a color outside of {'red','blue','green','yellow'}.
  • If both puyo of a pair are dropped on the same column, the first one to come is on the top of the pair (in the example #1, red is dropped on the top of the blue on the column 1).

Output:

A single integer indicating the length of the combo.

Test cases:

Test case #1

Input
y1r1

Output
0

Test case #2

Input
r1r2g3r3g3g2g1r2

Output
2

Test case #3

Input
y1r1r2r3g2g3r2g3y2y3g3g3y1y1

Output
3

Test case #4

Input
b1b1r2b2g3g3r2r3y4y5b6b6b5y5g4b5y4g3b6b6

Output
1

Test case #5

Input
y1b2b3b3b5b5y6b6b4b4

Output
1

Test case #6

Input
y1r1r2r3g2g3r2g3y2y3g3g3y1y1

Output
3

Test case #7 (click me!)

Input
b1b2g3r4g5y6y1y2b3g4r5g6y1b2g3r4g5y6r1r2g3r4r5y6r1b2b3y4r5y6b1y2y3r4r5g6r1b2r3y4g5g6y1g2r3b4b5b6b1g2g3r4r5g6b1b2r3y4b5r6g1y2b2y3y4g4g5g6g5g6

Output
17

Standard Loopholes apply.

NB: for purists, I know that the 13th row is supposed to be invisible and that puyo that are in that column are not considered 'linked' to nearby puyo, but I figured this challenge was hard enough as-is.

@Sandbox please comment! I'd love to hear your thoughts about such a challenge. I will finish setting it up soon, adding some extra resources about the game (like this one). Questions:

  • Should I reverse the "top / bottom" puyo of a pair rule? The way it is now, it forces to parse input as pairs. If it is reversed, golfers can take puyo one by one and sort it all by columns, making the challenge easier.
  • What tags should it enter with?
  • I will make other test cases soon enough, but should I include a as a file (via pastebin)?
| |
\$\endgroup\$
0
\$\begingroup\$

De-interleave log lines

You've inherited a server that runs several apps which all output to the same log.

Your task is to de-interleave the lines of the log file by source. Fortunately, each line begins with a tag that indicates which app it is from.

Logs

Each line will look something like this:

[app_name] Something horrible happened!

App tags are always between square brackets and will contain only alphanumeric characters and underscores. All lines will have an app tag and the app tag will always be the first thing on the line.

Example

An entire log might look like this:

[weather] Current temp: 83F
[barkeep] Fish enters bar
[barkeep] Fish orders beer
[stockmarket] PI +3.14
[barkeep] Fish leaves bar
[weather] 40% chance of rain detected

Which should output three different logs:

[weather] Current temp: 83F
[weather] 40% chance of rain detected
[barkeep] Fish enters bar
[barkeep] Fish orders beer
[barkeep] Fish leaves bar
[stockmarket] PI +3.14

You are not given the names of the app tags ahead of time. You must determine them only by analyzing the log file.

Rules and Scoring

  • This is , so shortest code wins.
  • Standard rules and loopholes apply
  • Use any convenient IO format, provided that each line is represented as a string, not a parsed tag + message.

| |
\$\endgroup\$
-1
\$\begingroup\$

Every number is interesting

We know that every number is interesting but how?

You should write a program or function which:

  • takes a list of N positive integers (>0 and <2^31)
  • outputs N lines each of them showing how the corresponding input number is interesting
  • is not longer than 1024 bytes
  • uses no more than 1 second per number
  • doesn't use external sources

Examples

172: 444 in base6
5776: 76*76
9801: 9 * 1089 (reverse)
68101: no 11 in base2 (10000101000000101)
491033: 317 * 1549 (product of 2 big primes)
467808816: no digit 5 from base6 to base10

Inputs

You should include the output for the following input in your post:

58 92 120 224 358 490 912 1578 7812 222008 1645060 19796411 550453633 

If you care to run your program on a bigger sample and share the result with us use this input data (2500 numbers). (You can upload your output to e.g. pastebin.)

This is a popularity-contest so highest voted answer wins.

Tags: popularity-contest, number

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ What sort of criteria are necessary for defining a number as 'interesting'? I see things like square numbers, other bases, etc. But are there any specifics? I'm interested in this challenge (but worried it might be closed as too broad). \$\endgroup\$ – ASCIIThenANSI Apr 7 '15 at 13:18
  • \$\begingroup\$ @ASCIIThenANSI There wasn't a clear definition. That's part of the reason why I abandoned the challenge. \$\endgroup\$ – randomra Apr 8 '15 at 1:55
  • 1
    \$\begingroup\$ Would you mind if I tried taking it up? I would have to post as a new answer, because I can't directly edit. \$\endgroup\$ – ASCIIThenANSI Apr 8 '15 at 2:00
  • \$\begingroup\$ @ASCIIThenANSI Not at all. \$\endgroup\$ – randomra Apr 8 '15 at 2:01
  • \$\begingroup\$ @ASCIIThenANSI Where did you post it? \$\endgroup\$ – wizzwizz4 Jul 24 '19 at 13:33
  • \$\begingroup\$ @ASCIIThenANSI I am also curious \$\endgroup\$ – MilkyWay90 Aug 27 '19 at 23:41
-1
\$\begingroup\$

Golf Cubically code

Your task is to optimize Cubically source code using one or more optimizations in this post.

How this challenge works:

  • You will choose one or more optimizations below and write a program (in the language of your choice) that performs those optimizations on a Cubically program.
  • Your program will take a Cubically program as input using any allowed input methods, and output a Cubically program using any allowed output methods.
  • The first answer to successfully perform all optimizations wins!

Optimizations

1. Face turn arguments

Before a face turn is performed, the interpreter calculates turns = turns mod 4. So R5 would be equivalent to R1 which is equivalent to R, R7 is equivalent to R3 which is equivalent to R', etc. Also note that R11111 is equivalent to R5, and R22 is equivalent to nothing at all.

Performing this optimization will mean evaluating all arguments to an R, L, U, D, M, E, or S command and shortening them as much as possible.

Test cases:

Relevant code -> Optimization
R11           -> R2
R1            -> R
L33           -> L2
U22           ->
D222          -> D2
M11111        -> M
E00001        -> E
S9            -> S

2. Repeated face turn

When multiple calls to the same face turn command are present right next to each other, they can clearly be golfed. For example, R2R1 is equivalent to R3. UUU is equivalent to U3. F2F2F2F2 is equivalent F8.

Test cases:

Relevant code -> optimization
R2R2R2        -> R6            (R2 if you also choose optimization 1)
LLL           -> L3
UU            -> UU or U2
D3D2D1        -> D6            (D2 if you also choose optimization 1)

3. "Set notepad to" commands

There are some commands that, instead of adding to/subtracting from/multiplying by/dividing by the notepad, just assign to it. Here are all such commands:

_^=<>⊕«»·|:

When called with multiple arguments, since each argument calls the command separately, only the final argument is relevant. So =123 is equivalent to =3, _00000 is equivalent to _0, and :12345678987654321 is equivalent to 1.

Test cases:

Relevant code -> Optimization
_333          -> _3
=12321        -> =1
+54321        -> +54321
:55           -> :5
/55           -> /55

4. Repeated non-face-turn commands

When multiple face turn commands are present right by each other, their arguments can simply be added together. Commands do not act this way. While R2 calls R with 2, =2 calls = with the face sum of the front face (face index 2).

To perform this optimization, when multiple commands outside of RLUDFBMES appear next to each other, simply remove the duplicated commands without removing the arguments.

Relevant code -> Optimization
_1_1_1_1      -> _1111         (_1 if you also choose optimization 3)
%11%22%33     -> %112233       (%3 if you also choose optimization 3)
+12345+67+8   -> +12345678

5. Nonexistent commands

Go check out the Cubically commands page and you'll see that there are plenty of characters that are not commands. For example, there are no commands that are lowercase letters.

To perform this optimization, remove all nonexistent commands and their arguments from the Cubically source. If the commands also have arguments, you must remove the arguments so that they are not passed to the previous command.

Test cases:

Relevant code -> Optimization
moo cow moo   -> 
moo2cow2moo   -> 
misteR2 FOO   -> R2F
FEAR ME.      -> ERME
u1U2u3U4u5U6  -> U2U4U6   (nothing if you also choose optimization 1, U12 if you also choose optimization 2)

6. Non-implicit commands

There are lots of implicit commands in Cubically (RLUDFBMES()$~&E!), but there are plenty that need to be called with arguments. So %%%% is equivalent to nothing at all while %%2%% is equivalent to %2.

Test cases:

Relevant code -> Optimization
%%%%          -> 
$$$$          -> $$$$
++2++2++2     -> +2+2+2                 (+222 if you also choose optimization 4)
+++>--<-      -> Not Brainf**k, sorry!  (:P)

Sandbox

I'll add more optimizations later.

| |
\$\endgroup\$
  • \$\begingroup\$ Clarification on R123: That's the same as R6 and R2, not R3, right? Digits are summed, there are multidigit numbers? That would be better to specify \$\endgroup\$ – isaacg Aug 17 '17 at 20:13
  • \$\begingroup\$ A few things: first, I can't find the tag "fgitw", is there a typo? Second, does optimization 1 require handling F and B as well, or just the currently listed ones? Third, in optimization 3 most of the listed commands seem invalid because the notepad is used in calculation and then overwritten with the output; for example =11 is not the same as =1 in most circumstances. In fact, I think only _: are valid. Fourth, is the winning answer one which performs all optimizations in a single program, or one which contains a separate program for each optimization? \$\endgroup\$ – Kamil Drakari Aug 18 '17 at 18:03
-1
\$\begingroup\$

Proper Kerning

Kerning is the adjustment of spacing between pairs of letters in order to obtain an aesthetic result. When kerning is applied automatically by a program (typically whatever editor you're using), it is said to be automatic. There are two types of automatic kerning. The one used in this challenge is metric kerning. With metric kerning, the amount of space between pairs of letters is dictated by the kerning tables found in the font file.

Given a TrueType font file, output the kerning values for each mapping in the kerning table for ASCII characters 48 - 122 inclusive.

Example

calibri.ttf

l="A" r="C" v="-15"
l="A" r="G" v="-15"
l="A" r="J" v="23"
l="A" r="O" v="-23"
l="A" r="Q" v="-23"
l="A" r="T" v="-160"
l="A" r="U" v="-32"
l="A" r="V" v="-89"
l="A" r="W" v="-80"
l="A" r="Y" v="-150"
l="A" r="t" v="-52"
l="A" r="v" v="-38"
l="A" r="y" v="-41"
l="A" r="?" v="-68"
l="B" r="A" v="-20"
l="B" r="T" v="-48"
l="B" r="V" v="-25"
l="B" r="W" v="-24"
l="B" r="X" v="-44"
l="B" r="Y" v="-57"
l="B" r="Z" v="-20"
l="B" r="f" v="-20"
l="B" r="t" v="-20"
l="B" r="v" v="-20"
l="B" r="x" v="-15"
l="B" r="y" v="-20"
l="C" r="G" v="-18"
l="C" r="J" v="12"
l="C" r="O" v="-18"
l="C" r="Q" v="-18"
l="C" r="T" v="10"
l="D" r="A" v="-30"
l="D" r="J" v="-22"
l="D" r="T" v="-23"
l="D" r="V" v="-24"
l="D" r="W" v="-14"
l="D" r="X" v="-31"
l="D" r="Y" v="-39"
l="D" r="Z" v="-22"
l="E" r="A" v="-22"
l="E" r="C" v="-24"
l="E" r="G" v="-24"
l="E" r="O" v="-32"
l="E" r="Q" v="-32"
l="E" r="S" v="-20"
l="E" r="Z" v="-10"
l="E" r="a" v="-34"
l="E" r="c" v="-28"
l="E" r="d" v="-30"
l="E" r="e" v="-37"
l="E" r="f" v="-64"
l="E" r="o" v="-37"
l="E" r="q" v="-30"
l="E" r="t" v="-24"
l="E" r="v" v="-48"
l="E" r="w" v="-34"
l="E" r="y" v="-48"
l="F" r="A" v="-115"
l="F" r="C" v="-18"
l="F" r="G" v="-18"
l="F" r="J" v="-109"
l="F" r="O" v="-18"
l="F" r="Q" v="-18"
l="F" r="S" v="-29"
l="F" r="X" v="-22"
l="F" r="Z" v="-11"
l="F" r="a" v="-55"
l="F" r="c" v="-28"
l="F" r="d" v="-20"
l="F" r="e" v="-30"
l="F" r="o" v="-28"
l="F" r="q" v="-20"
l="F" r="s" v="-35"
l="G" r="T" v="-10"
l="G" r="V" v="-10"
l="G" r="W" v="-9"
l="G" r="Y" v="-30"
l="G" r="v" v="-29"
l="G" r="w" v="-22"
l="G" r="x" v="-14"
l="G" r="y" v="-30"
l="J" r="A" v="-35"
l="J" r="X" v="-20"
l="K" r="C" v="-78"
l="K" r="G" v="-80"
l="K" r="O" v="-97"
l="K" r="Q" v="-97"
l="K" r="S" v="-18"
l="K" r="U" v="-29"
l="K" r="W" v="-34"
l="K" r="a" v="-34"
l="K" r="c" v="-40"
l="K" r="d" v="-33"
l="K" r="e" v="-37"
l="K" r="f" v="-25"
l="K" r="m" v="-32"
l="K" r="n" v="-32"
l="K" r="o" v="-37"
l="K" r="p" v="-32"
l="K" r="q" v="-33"
l="K" r="r" v="-32"
l="K" r="s" v="-18"
l="K" r="t" v="-38"
l="K" r="u" v="-32"
l="K" r="v" v="-101"
l="K" r="w" v="-95"
l="K" r="y" v="-85"
l="L" r="C" v="-22"
l="L" r="G" v="-47"
l="L" r="J" v="25"
l="L" r="O" v="-45"
l="L" r="Q" v="-45"
l="L" r="T" v="-150"
l="L" r="U" v="-44"
l="L" r="V" v="-147"
l="L" r="W" v="-118"
l="L" r="Y" v="-167"
l="L" r="f" v="-23"
l="L" r="t" v="-38"
l="L" r="v" v="-78"
l="L" r="w" v="-72"
l="L" r="y" v="-79"
l="O" r="A" v="-23"
l="O" r="J" v="-27"
l="O" r="T" v="-55"
l="O" r="V" v="-25"
l="O" r="W" v="-22"
l="O" r="X" v="-64"
l="O" r="Y" v="-55"
l="O" r="Z" v="-38"
l="O" r="x" v="-12"
l="O" r="z" v="-10"
l="P" r="A" v="-151"
l="P" r="J" v="-140"
l="P" r="T" v="-9"
l="P" r="V" v="-10"
l="P" r="X" v="-35"
l="P" r="Y" v="-11"
l="P" r="Z" v="-29"
l="P" r="a" v="-44"
l="P" r="c" v="-43"
l="P" r="d" v="-34"
l="P" r="e" v="-41"
l="P" r="f" v="12"
l="P" r="o" v="-41"
l="P" r="q" v="-34"
l="P" r="s" v="-32"
l="P" r="t" v="12"
l="P" r="y" v="12"
l="Q" r="J" v="41"
l="Q" r="T" v="-47"
l="Q" r="V" v="-25"
l="Q" r="W" v="-12"
l="Q" r="X" v="12"
l="Q" r="Y" v="-46"
l="Q" r="g" v="59"
l="Q" r="j" v="79"
l="Q" r="x" v="31"
l="Q" r=";" v="60"
l="Q" r="]" v="32"
l="R" r="C" v="-18"
l="R" r="G" v="-19"
l="R" r="O" v="-20"
l="R" r="Q" v="-20"
l="R" r="S" v="-27"
l="R" r="T" v="-20"
l="R" r="V" v="-28"
l="R" r="W" v="-18"
l="R" r="Y" v="-30"
l="R" r="e" v="-36"
l="R" r="o" v="-42"
l="R" r="v" v="-26"
l="R" r="w" v="-33"
l="R" r="y" v="-33"
l="S" r="A" v="-15"
l="S" r="J" v="-9"
l="S" r="T" v="-14"
l="S" r="V" v="-14"
l="S" r="W" v="-15"
l="S" r="X" v="-13"
l="S" r="Y" v="-20"
l="S" r="v" v="-23"
l="S" r="w" v="-17"
l="S" r="y" v="-25"
l="T" r="A" v="-160"
l="T" r="C" v="-42"
l="T" r="G" v="-59"
l="T" r="J" v="-65"
l="T" r="O" v="-58"
l="T" r="Q" v="-58"
l="T" r="S" v="-10"
l="T" r="T" v="28"
l="T" r="a" v="-160"
l="T" r="c" v="-177"
l="T" r="d" v="-147"
l="T" r="e" v="-182"
l="T" r="g" v="-151"
l="T" r="m" v="-127"
l="T" r="n" v="-127"
l="T" r="o" v="-182"
l="T" r="p" v="-127"
l="T" r="q" v="-147"
l="T" r="r" v="-127"
l="T" r="s" v="-153"
l="T" r="u" v="-127"
l="T" r="v" v="-92"
l="T" r="w" v="-86"
l="T" r="x" v="-90"
l="T" r="y" v="-93"
l="T" r="z" v="-142"
l="T" r=";" v="-114"
l="T" r=":" v="-134"
l="U" r="A" v="-45"
l="U" r="J" v="-40"
l="V" r="A" v="-96"
l="V" r="C" v="-18"
l="V" r="G" v="-25"
l="V" r="J" v="-80"
l="V" r="O" v="-27"
l="V" r="Q" v="-27"
l="V" r="S" v="-12"
l="V" r="V" v="9"
l="V" r="a" v="-114"
l="V" r="c" v="-103"
l="V" r="d" v="-87"
l="V" r="e" v="-102"
l="V" r="g" v="-100"
l="V" r="m" v="-50"
l="V" r="n" v="-50"
l="V" r="o" v="-86"
l="V" r="p" v="-50"
l="V" r="q" v="-87"
l="V" r="r" v="-50"
l="V" r="s" v="-90"
l="V" r="u" v="-50"
l="V" r="y" v="-35"
l="V" r="z" v="-82"
l="V" r=";" v="-108"
l="V" r=":" v="-73"
l="W" r="A" v="-93"
l="W" r="C" v="-22"
l="W" r="G" v="-22"
l="W" r="J" v="-88"
l="W" r="O" v="-22"
l="W" r="Q" v="-22"
l="W" r="S" v="-10"
l="W" r="X" v="-13"
l="W" r="a" v="-71"
l="W" r="c" v="-78"
l="W" r="d" v="-72"
l="W" r="e" v="-75"
l="W" r="g" v="-54"
l="W" r="m" v="-60"
l="W" r="n" v="-60"
l="W" r="o" v="-86"
l="W" r="p" v="-60"
l="W" r="q" v="-72"
l="W" r="r" v="-60"
l="W" r="s" v="-73"
l="W" r="u" v="-60"
l="W" r="v" v="-34"
l="W" r="y" v="-53"
l="W" r=";" v="-156"
l="X" r="C" v="-57"
l="X" r="G" v="-65"
l="X" r="O" v="-57"
l="X" r="Q" v="-57"
l="X" r="S" v="-20"
l="X" r="d" v="-44"
l="X" r="e" v="-39"
l="X" r="g" v="-9"
l="X" r="o" v="-38"
l="X" r="q" v="-44"
l="X" r="t" v="-31"
l="X" r="u" v="-38"
l="X" r="v" v="-55"
l="X" r="w" v="-49"
l="X" r="y" v="-43"
l="Y" r="A" v="-152"
l="Y" r="C" v="-67"
l="Y" r="G" v="-67"
l="Y" r="J" v="-112"
l="Y" r="O" v="-66"
l="Y" r="Q" v="-66"
l="Y" r="S" v="-17"
l="Y" r="Z" v="-10"
l="Y" r="a" v="-134"
l="Y" r="c" v="-159"
l="Y" r="d" v="-131"
l="Y" r="e" v="-147"
l="Y" r="f" v="-62"
l="Y" r="g" v="-142"
l="Y" r="i" v="-32"
l="Y" r="j" v="-49"
l="Y" r="m" v="-94"
l="Y" r="n" v="-94"
l="Y" r="o" v="-153"
l="Y" r="p" v="-94"
l="Y" r="q" v="-131"
l="Y" r="r" v="-94"
l="Y" r="s" v="-115"
l="Y" r="t" v="-44"
l="Y" r="u" v="-94"
l="Y" r="v" v="-69"
l="Y" r="w" v="-62"
l="Y" r="x" v="-70"
l="Y" r="y" v="-65"
l="Y" r="z" v="-100"
l="Y" r=";" v="-138"
l="Y" r=":" v="-154"
l="Z" r="A" v="-11"
l="Z" r="C" v="-25"
l="Z" r="G" v="-24"
l="Z" r="O" v="-24"
l="Z" r="Q" v="-24"
l="Z" r="W" v="-7"
l="Z" r="Y" v="-7"
l="Z" r="a" v="-10"
l="Z" r="c" v="-12"
l="Z" r="d" v="-18"
l="Z" r="e" v="-31"
l="Z" r="o" v="-29"
l="Z" r="q" v="-18"
l="Z" r="v" v="-45"
l="Z" r="w" v="-38"
l="Z" r="y" v="-37"
l="a" r="f" v="-12"
l="a" r="t" v="-19"
l="a" r="v" v="-34"
l="a" r="w" v="-14"
l="a" r="x" v="-19"
l="a" r="y" v="-38"
l="b" r="f" v="-17"
l="b" r="s" v="-10"
l="b" r="t" v="-9"
l="b" r="v" v="-10"
l="b" r="w" v="-10"
l="b" r="x" v="-41"
l="b" r="y" v="-10"
l="b" r="z" v="-28"
l="c" r="a" v="-17"
l="c" r="o" v="-17"
l="e" r="f" v="-18"
l="e" r="t" v="-11"
l="e" r="v" v="-10"
l="e" r="w" v="-10"
l="e" r="x" v="-31"
l="e" r="y" v="-13"
l="e" r="z" v="-20"
l="f" r="a" v="-40"
l="f" r="c" v="-45"
l="f" r="d" v="-53"
l="f" r="e" v="-51"
l="f" r="f" v="-20"
l="f" r="g" v="-60"
l="f" r="o" v="-43"
l="f" r="q" v="-53"
l="f" r="s" v="-27"
l="f" r="v" v="13"
l="f" r="w" v="6"
l="f" r="y" v="10"
l="f" r="z" v="-20"
l="g" r="a" v="-38"
l="g" r="c" v="-12"
l="g" r="d" v="-19"
l="g" r="e" v="-17"
l="g" r="g" v="19"
l="g" r="o" v="-14"
l="g" r="q" v="-19"
l="g" r="t" v="-31"
l="h" r="f" v="-12"
l="h" r="t" v="-19"
l="h" r="v" v="-34"
l="h" r="w" v="-14"
l="h" r="x" v="-19"
l="h" r="y" v="-38"
l="k" r="a" v="-35"
l="k" r="c" v="-48"
l="k" r="d" v="-56"
l="k" r="e" v="-66"
l="k" r="o" v="-69"
l="k" r="q" v="-56"
l="k" r="s" v="-19"
l="k" r="t" v="-10"
l="k" r="u" v="-26"
l="m" r="f" v="-12"
l="m" r="t" v="-19"
l="m" r="v" v="-34"
l="m" r="w" v="-14"
l="m" r="x" v="-19"
l="m" r="y" v="-38"
l="n" r="f" v="-12"
l="n" r="t" v="-19"
l="n" r="v" v="-34"
l="n" r="w" v="-14"
l="n" r="x" v="-19"
l="n" r="y" v="-38"
l="o" r="v" v="-9"
l="o" r="w" v="-8"
l="o" r="x" v="-40"
l="o" r="y" v="-11"
l="o" r="z" v="-27"
l="p" r="f" v="-17"
l="p" r="s" v="-10"
l="p" r="t" v="-9"
l="p" r="v" v="-10"
l="p" r="w" v="-10"
l="p" r="x" v="-41"
l="p" r="y" v="-10"
l="p" r="z" v="-28"
l="q" r="g" v="10"
l="r" r="a" v="-42"
l="r" r="c" v="-30"
l="r" r="d" v="-28"
l="r" r="e" v="-27"
l="r" r="g" v="-28"
l="r" r="o" v="-33"
l="r" r="q" v="-28"
l="r" r="s" v="-35"
l="r" r="v" v="19"
l="r" r="w" v="11"
l="r" r="y" v="10"
l="s" r="f" v="-19"
l="s" r="t" v="-23"
l="s" r="v" v="-31"
l="s" r="w" v="-10"
l="s" r="x" v="-22"
l="s" r="y" v="-37"
l="s" r="z" v="-18"
l="t" r="a" v="-25"
l="t" r="c" v="-25"
l="t" r="d" v="-23"
l="t" r="e" v="-22"
l="t" r="o" v="-20"
l="t" r="q" v="-23"
l="t" r="t" v="-29"
l="v" r="a" v="-30"
l="v" r="c" v="-25"
l="v" r="d" v="-20"
l="v" r="e" v="-20"
l="v" r="f" v="11"
l="v" r="g" v="-28"
l="v" r="o" v="-19"
l="v" r="q" v="-20"
l="v" r="s" v="-9"
l="v" r="t" v="10"
l="v" r="v" v="12"
l="v" r="w" v="12"
l="v" r="y" v="12"
l="v" r="z" v="-26"
l="w" r="a" v="-23"
l="w" r="c" v="-20"
l="w" r="d" v="-18"
l="w" r="e" v="-18"
l="w" r="f" v="6"
l="w" r="g" v="-18"
l="w" r="o" v="-19"
l="w" r="q" v="-18"
l="w" r="s" v="-18"
l="w" r="t" v="4"
l="w" r="v" v="12"
l="w" r="w" v="8"
l="w" r="y" v="12"
l="w" r="z" v="-17"
l="x" r="a" v="-37"
l="x" r="c" v="-46"
l="x" r="d" v="-44"
l="x" r="e" v="-54"
l="x" r="o" v="-55"
l="x" r="q" v="-44"
l="x" r="s" v="-12"
l="x" r="t" v="6"
l="x" r="u" v="-20"
l="y" r="a" v="-31"
l="y" r="c" v="-26"
l="y" r="d" v="-24"
l="y" r="e" v="-25"
l="y" r="f" v="10"
l="y" r="g" v="-26"
l="y" r="o" v="-24"
l="y" r="q" v="-24"
l="y" r="s" v="-19"
l="y" r="t" v="10"
l="y" r="v" v="12"
l="y" r="w" v="8"
l="y" r="y" v="10"
l="y" r="z" v="-17"
l="z" r="a" v="-34"
l="z" r="c" v="-45"
l="z" r="d" v="-46"
l="z" r="e" v="-46"
l="z" r="f" v="-10"
l="z" r="g" v="-17"
l="z" r="o" v="-45"
l="z" r="q" v="-46"
l="z" r="s" v="-22"
l="z" r="u" v="-10"
l="z" r="v" v="-18"
l="z" r="w" v="-22"
l="z" r="y" v="-18"

Scoring

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

Meta

I know this challenge is going to need a lot of work before it's ready for main. Please hold criticisms for now. Helpful ideas and thoughts are welcome.

| |
\$\endgroup\$
  • \$\begingroup\$ I'm not sure that the problem is well defined. There's a reason it's called font hinting: the rendering application is free to take it into account or not, or even to apply more complex logic. E.g. some fonts have multiple sets of font hints for different contexts. There are other complex issues. A font can have Latin and Cyrillic letters and define hints for kerning between pairs of Latin and pairs of Cyrillic but not between Latin and Cyrillic; however, some letters may have identical glyphs, so a judgement on whether the kerning is "correct" might be ambiguous. Then there's antialiasing. \$\endgroup\$ – Peter Taylor May 24 '17 at 6:15
  • \$\begingroup\$ @PeterTaylor Good notes. I will likely restrict the character set. I just wanted to start getting ideas down in the sandbox. \$\endgroup\$ – Poke May 24 '17 at 6:51
  • \$\begingroup\$ Very ambiguous. \$\endgroup\$ – dkudriavtsev May 25 '17 at 17:48
  • \$\begingroup\$ @Mendeleev It's not done yet. I'm aware it's ambiguous. \$\endgroup\$ – Poke May 26 '17 at 16:10
  • \$\begingroup\$ Looking at developer.apple.com/fonts/TrueType-Reference-Manual/RM06/… I can see a number of issues to address. 16- vs 32-bit entries? Should multiple tables be combined or printed separately? All tables or only tables with certain coverage values? Which of the four defined formats need to be supported? Do you have a test case which covers glyph index differing from codepoint? \$\endgroup\$ – Peter Taylor Sep 16 '17 at 17:28
  • \$\begingroup\$ @PeterTaylor I have a proof of concept that I wrote (it's the reason I have taken so long to update this) and I'm planning to address all of your questions. Thanks for doing a bit of research to help me out, though :] \$\endgroup\$ – Poke Sep 16 '17 at 18:57
  • \$\begingroup\$ Downvoter, why? \$\endgroup\$ – Poke Oct 4 '17 at 21:03
-1
\$\begingroup\$

Six Flags over HTTP

Let's say you need to transmit six boolean flags in a URL string. Obviously you could do it with six ones or zeroes, but you want better compression. With a little math you can pack them into two characters using 0-7 octal.

How about mapping all six to a single ASCII character? Here we have a problem: you are not allowed to use , / ? : @ & = + $ # or space. Now the range of printable ASCII no longer has 64 valid characters in a row.

In Javascript (or another language that can run from a web page, if any), what is the shortest code for a pair of functions to encode and decode this data, between an array of six booleans and a single character?

| |
\$\endgroup\$
  • \$\begingroup\$ -1 language restriction, most languages have HTTP libraries so I think any language should be allowed \$\endgroup\$ – ASCII-only Sep 24 '17 at 13:11
  • \$\begingroup\$ This challenge could be improved by rephrasing it to: "Write a bijective function between an array of six booleans and a single printable character excluding the characters ,/?:@&=+$# ". Mentioning that the encoder and decoder should be separate programs/functions would be helpful. Also, may the encoder and decoder share code? \$\endgroup\$ – fireflame241 Sep 24 '17 at 22:08
-1
\$\begingroup\$

Count letter frequency

Inspired by question Tweetable hash function challenge, you should take the English dictionary used there and produce a program or function that outputs the the absolute and relative frequency of each character. It is CASE SENSITIVE and the APOSTROPHE is also accountable as a real letter.

Example of a valid output format (but with stupid guessing values):

A      5566    20%
...
Z        60     0.2%
a     27000    30%
...
z       120     0.01%
'       450     3.5%

It is , but no answer will be accepted. Wanna know shortest script for each language.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ -1 (01) Don't rely on another challenge to define yours; include all the information we need in your write-up. (02) Make an effort to come up with some actual test cases - do you honestly expect us to verify our solutions against "stupid guessing values"? \$\endgroup\$ – Shaggy Sep 30 '17 at 0:55
-1
\$\begingroup\$

Is it a perfect loop?

Your task is to take a GIF or an animated image in any reasonable format as input (including taking the file name of a GIF in the current directory), and output whether it is a "perfect loop" - that is, the frames transition seamlessly from the end to the start, and a human cannot notice where it starts and ends at first glance. Return or print a truthy value if it is a perfect loop, otherwise print or return a falsy value.

Scoring

Winners will be determined from the percentage of test cases they get correct. In the event of a tie, highest votes wins. You can view test cases at https://ghostbin.com/paste/m3yaw. Show your score against the test cases when you post.

Input

If you are not taking input in a GIF, please provide a program that will convert a GIF to your desired format.

Images corresponding to a truthy value have been taken from /r/perfectloops and for falsy test cases, /r/almostperfectloops and /r/gifs.

Restrictions

  • Hard coding is not allowed (violates standard loophole 1 and 2).
  • You must provide consistent results for the same GIF (no randomness)
  • Remember, this is not , so byte count is not needed in your solution. Just post the language name and add the percentage correct when I comment.
| |
\$\endgroup\$
  • \$\begingroup\$ I'm not sure it's as simple as comparing the first to the last frame, if it is we'd have duplicate frames. is this challenge allowing HTTP requests? \$\endgroup\$ – tuskiomi Oct 17 '17 at 21:15
  • \$\begingroup\$ If hashing the inputs is not allowed, then you should clearly define what constitutes a “perfect loop”. It's not good to extrapolate from a handful of test cases where the pass/fail cases are very similar. \$\endgroup\$ – japh Oct 18 '17 at 14:31
-1
\$\begingroup\$

Removing a Letter adds a Letter

Your program should output nothing when unaltered, however, when any single character is removed it should have an output length of 1. This extends to any number of characters being removed from the program, as long as there is, at minimum, a single character remaining.


For example, if my program were abcdefg, it should output nothing if unaltered.

However, if I were to remove a and d from this program to get bcefg, it should output any two printable characters that represent 16 bytes of information (2 characters for 2 characters removed).

  • So if bcefg outputs (00,AA,etc...) this is valid.

Taking this further, if we were to remove all but the letter g we'd need an output of 6 characters.

  • So if g outputs ('000000','@$^%@(',etc...) this is valid.

Your program must function for all possible combinations of removals that are possible, that is to say each single letter in your program should be a valid program.


Rules

  • You may "lock" pieces of the code, each locked byte counts for 2-bytes instead of 1-byte.
    • Locked bytes will never be removed.
    • For instance, if my program was abcdefg and bcd is locked, the shortest program we'll get is abcd,bcde,bcdf and bcdg.
    • If bcd was locked in abcdefg it'd be 10 bytes, not 7.
  • The program may output any byte to represent 1 removed character, N-bytes for N removed chars in the code itself.
| |
\$\endgroup\$
  • \$\begingroup\$ The rule only leads to totally locked code \$\endgroup\$ – l4m2 Mar 13 '18 at 0:13
  • \$\begingroup\$ @l4m2 hah. I disagree. \$\endgroup\$ – Magic Octopus Urn Mar 13 '18 at 0:58
  • \$\begingroup\$ But more constructively, increase the penalty? Limit locked chars? \$\endgroup\$ – Magic Octopus Urn Mar 13 '18 at 1:04
  • \$\begingroup\$ Maybe require an unlocked percent? \$\endgroup\$ – l4m2 Apr 6 '18 at 10:52
-1
\$\begingroup\$

Non-true, non-false JS boolean

Array prototype isn't redefined, input hasn't getters

function magic(input){
  let result = [];
  if(input.boolean != true){result.push("non-true");}
  if(input.boolean != false){result.push("non-false");}
  result.push(input);
  return result.join("\n");
}

returns

non-true
non-false
{"boolean": true}

What is passed to magic function?

Based on real problem :) I spent 30 minutes on this puzzle

| |
\$\endgroup\$
  • 5
    \$\begingroup\$ This site is for programming contests, not pure programming puzzles. Thanks for using the sandbox, anyway. \$\endgroup\$ – user202729 Feb 1 '18 at 12:11
  • 7
    \$\begingroup\$ Contrary to what user202729 states, Programming Puzzles are on-topic on this site. This challenge could use a little cleanup to make it a better fit here (for example, what language is this?), but this challenge is indeed allowed here. \$\endgroup\$ – AdmBorkBork Feb 1 '18 at 14:02
  • \$\begingroup\$ ... someone said that I'm wrong. Anyway people definitely doesn't like this. \$\endgroup\$ – user202729 Feb 1 '18 at 14:02
  • \$\begingroup\$ @AdmBorkBork this is JS \$\endgroup\$ – Евгений Новиков Feb 1 '18 at 14:41
  • 3
    \$\begingroup\$ @ЕвгенийНовиков what JS version is this? in is a keyword, and can't be a variable name. \$\endgroup\$ – dzaima Feb 1 '18 at 14:47
  • \$\begingroup\$ @dzaima Good point. Last time I check on TIO the object {boolean: true} doesn't have " around and it caused a syntax error. I forgot about in so just try to rename it and it worked... \$\endgroup\$ – user202729 Feb 1 '18 at 14:51
  • \$\begingroup\$ "Programming Puzzle" is in the name of the site @user202729 \$\endgroup\$ – dylnan Feb 1 '18 at 15:46
  • \$\begingroup\$ @dylnan But... \$\endgroup\$ – user202729 Feb 1 '18 at 15:55
  • \$\begingroup\$ @AdmBorkBork is correct. We do allow programming puzzles. \$\endgroup\$ – Nathan Merrill Feb 1 '18 at 16:25
  • \$\begingroup\$ @NathanMerrill Then just upvote the comment. \$\endgroup\$ – user202729 Feb 2 '18 at 5:34
  • \$\begingroup\$ Many many things in the past, including but not limited to, code-trolling, underhanded, non-observable behavior, etc. are off-topic or heavily-discouraged nowadays. Be careful. \$\endgroup\$ – user202729 Feb 2 '18 at 5:34
  • \$\begingroup\$ @user202729 I did upvote. I just wanted to make sure it was extra clear to the OP. Furthermore, this challenge doesn't fit any of those tags, because its not asking for trolling/underhanded/non-observable code. You could argue that the code in the challenge fits those tags, but that's not what we care about. \$\endgroup\$ – Nathan Merrill Feb 2 '18 at 5:51
  • 2
    \$\begingroup\$ I don't believe that console is part of any JS spec. This presumably only works in certain contexts, and the question should specify what they are. Otherwise the task devolves into code-trolling by defining a suitable console. It's already borderline IMO. \$\endgroup\$ – Peter Taylor Feb 2 '18 at 12:04
  • \$\begingroup\$ @dzaima sorry, fixed this. Now input variable is input \$\endgroup\$ – Евгений Новиков Feb 3 '18 at 7:40
  • 1
    \$\begingroup\$ OK, so, in that case you may want to work on the wording of the challenge before posting it to Main because, right now, it reads as though you've come across this challenge elsewhere, spent half an hour trying to solve and are now looking for help doing so. Also, just so you know, restricted language challenges rarely go down well here. \$\endgroup\$ – Shaggy Feb 3 '18 at 19:20
-1
\$\begingroup\$

Sandbox:

Is this question already available (duplicate)?

Are things too vague?

Does providing the example help or hinder?

Tidy the Pantry (easy)

I hate grocery shopping, particularly the part where I put groceries away--so I'm calling upon the collective hive-mind to handle that.

Challenge

Your challenge is to take a 1D-list of groceries and a 2D pantry as input; and output an newly assorted pantry. The two variables can be of your type choice, and in any order, but please specify what item types your program requires (e.g. string, array, etc.).

Rules & Additional info.

Scoring

  • This is code golf, so the shortest answer in bytes wins

Rules

  • The pantry should be ordered alphabetically (A - Z, left to right, top to bottom)
    • For simplicity, the pantry is case-insensitive
  • The pantry must retain its horizontal size (but trailing newlines are optional)
  • "Pockets" (empty spaces) should be filled between items (i.e. only the last item is allowed to have a trailing pocket)
  • If the pantry is too small for the incoming groceries, then the pantry must replace older items (Z being the oldest, A the youngest)
    • Z from groceries is younger than A in pantry
  • Standard loopholes are forbidden

Examples ([ and ] are used for readability)

Input (4x4 pantry):

[A][A][ ][ ]
[ ][ ][B][ ]
[C][ ][ ][ ]
[ ][ ][ ][D]

AAD

Output:

[A][A][A][A]
[B][C][D][D]
[ ][ ][ ][ ]
[ ][ ][ ][ ]

Input (2x2 pantry):

[A][B]
[C][D]

XYZ

Output:

[A][X]
[Y][Z]

Example solution

JavaScript ES6 (989 bytes)

// (String, String) -> String
let organise = (pantry, groceries) => {
  let n = pantry.split("\n").sort((a, b) => b.length - a.length); // used at the end of the function for horizontal sizing
  n = n[0].length;

  pantry = pantry
    .replace(/\W/g, "") // get rid of all non-alphanumeric characters
    .split("");         // turn the string into an array

  // we need the properties of the new array
  // so the extra `pantry = pantry` is needed
  pantry = pantry
    .slice(0, pantry.length - groceries.length) // go ahead and remove the last overlapping elements
    .concat(groceries)                          // add the groceries to the pantry
    .join("")                                   // turn into a string
    .split("")                                  // turn into an array
    .sort()                                     // sort the array
    .join("");                                  // turn into a string

    return pantry.replace(RegExp(`(.{${n}})`, 'g'), "$1\n");
};

/** Testing below **/

console.log("Test #2:\n" + organise(
`AJCHDJE
JJ   JA
    ASD
OOQ I U
Q     W
      R`,

'AHJBCJHDHHATTGEH'
))


Test Cases:

Test #1, 4x4 pantry

TVCX <- pantry
ABCD
ATDJ
UAIK

XYXY <- groceries
----
AAAB <- expected output
CCDD
IJKT
XYXY

Test #2, 7x6 pantry

AJCHDJE
JJ   JA
    ASD
OOQ I U
Q     W
      R

AHJBCJHDHHATTGEH
-------
AAAAABC
CDDDEGH
HHHHJJT
T

Test #3, 10x10 pantry

AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA

ZZZZZZZZZZZZZZZZZZZZ
----------
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
AAAAAAAAAA
ZZZZZZZZZZ
ZZZZZZZZZZ

Test #4, 16x16 pantry pantry

ASDFGHJKLZXCVBNM
QJKAJ  KAKSJD  J
KJASDKFHI YOIER
W   OSDOFJ    DK
E PPPASP     AS
R
TASD 
YAAAAAAAAAAAA
U          JHOLK
IIAUSHODUYOAISUO
OASD  AUSODI 
PIASND JUASJNOIJ
A ASJDH PPOIO 
QHIAIUSOIUOOO
WYYAIUSNNAJSDASD
EAISDUUIOPJPIJPJ
ROQPEWIHRNXCAISD

QWERTYUIOP
----------------
AAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAA
ABCCDDDDDDDDDDDD
DDDEEEEEFFFGHHHH
HHHIIIIIIIIIIIII
IIIIIIJJJJJJJJJJ
JJJJJJKKKKKKKKLL
MNNNNNNOOOOOOOOO
OOOOOOOOOOPPPPPP
PPPPPPQQQQRRRRRS
SSSSSSSSSSSSSSSS
SSSTTUUUUUUUUUUU
UVWWY

Test #5, 2x2 pantry

HE
LO

[no groceries]
--
HE
LO
| |
\$\endgroup\$
  • 1
    \$\begingroup\$ why divide the program score? \$\endgroup\$ – RedClover Feb 26 '18 at 19:03
  • 1
    \$\begingroup\$ I recommend you do count by bytes otherwise someone is just going to encode their entire program in Chinese characters and win. \$\endgroup\$ – HyperNeutrino Feb 26 '18 at 19:09
  • \$\begingroup\$ @labela--gotoa To get a golfed score (smaller programs get a smaller score), should I change it? \$\endgroup\$ – Ephellon Dantzler Feb 26 '18 at 19:13
  • \$\begingroup\$ @EphellonDantzler I don't understand why not just normal scoring...? \$\endgroup\$ – RedClover Feb 26 '18 at 19:14
  • \$\begingroup\$ LOL, that's why I set in in Sandbox first @labela--gotoa \$\endgroup\$ – Ephellon Dantzler Feb 26 '18 at 19:16
  • 1
    \$\begingroup\$ Some notes on your reference implementation: 1 It appears far too soon in the challenge. 2 It's not 1768 bytes. 3 You need to ungolf it and make it readable or it's not much use. 4 As it's JS, create a Snippet for it. 5 Is it necessary? It seems to be thrown in there to try to patch over any holes in the challenge spec. \$\endgroup\$ – Shaggy Feb 26 '18 at 23:17
-1
\$\begingroup\$

Interpret pseudocode

Wikipedia says pseudocode

is intended for human reading rather than machine reading.

and

A program in pseudocode is not an executable program.

I don't care.

Make a pseudocode interpreter that can run pseudocode that fits the rules described below*. This is based on the IB pseudocode guide, but it is simplified quite a bit to make it fit for the challenge.


Pseudocode specifications

This is a simplified pseudocode to make the challenge less tedious. The pseudocode language has no strings, no arrays, no classes, no methods, and no variables other than integers.

Basic syntax

Comments that start at // and end at a newline (like java one-line comments). // is not necessarily followed by a space, and the comment may be empty. Example:

A = 2 + 3 // I can't write five because my keyboard is broken

Statements are separated by newlines. Lines may be empty (without statements). The exact number of spaces doesn't matter, and spaces are not required. The language is case sensitive.

Variables

All variables are global, and can be accessed anywhere. They do not need to be declared. To keep things simple, all variables can be assumed to be integers. All variable names are UPPERCASE, and consist only of letters. Your program should at least handle integers from -256 to 256. A wider range is not a requirement.

Variables are assigned values using this syntax:

VARIABLE = Expression

Where VARIABLE can be any uppercase name and expression can be any integer expression, as discussed below.

Examples:

A = 5
B = A + 3
NUMBER = A * B

Expressions

An expression can be:

  • An integer, like 42
  • A variable, like NUMBER
  • A binary operation on two other expressions, like NUMBER + 5. There are only four operations: +, -, *, /. Division rounds integers down.

Expressions can be surrounded by parentheses to indicate that they need to be evaluated first. To keep things simple, all expressions are evaluated from left to right no matter what the operations are (unless there are parentheses that specify otherwise), so

A = 2 - RM * 9 + 3 / NUMBER
B = 1 + 2 * (3 - 4) / 6

is equivalent to

A = (((2 - RM) * 9) + 3) / NUMBER
B = ((1 + 2) * (3 - 4)) / 6

Boolean expressions

Boolean expressions can compare two expressions using == (equality), != (not equal to), < (less than), and > (greater than). They are only used for control flow, as discussed below (there are no boolean variables).

Control flow

There are four types of control flow. They can be infinitely nested in all combinations.

If

if (booleanExpression) then
    // statements (discussed below)
endif

If-else

if (booleanExpression) then
    // statements (discussed below)
else
    // other statements
endif

Loop while

loop while (booleanExpression)
    // do stuff
endloop

Where booleanExpressions are boolean expressions. The ifs work the same as in normal programming languages. The while loop is a simple while loop.

The booleanExpressions will always be surrounded by (). The pseudocode is very flexible with spaces, and any number of spaces is valid.

Loop for

loop VARIABLE from Expression1 to Expression2
    // things to do over and over again
end loop

Where Expression1 and Expression2 are expressions that are evaluated before the loop begins and their values are stored until the loop finishes. The content of the loop is executed for every integer from the result of Expression1 to that of Expression1, inclusive. At every iteration, the index variable (VARIABLE in this case) is updated.

Example:

loop I from 3 to 5
    output(I)
endloop

Outputs:

3
4
5

Statements

Output

output(Expression) outputs the evaluated expression. It's like println in programming languages. So:

output(1+1)

prints 2, followed by a newline.

output() with no arguments should print a newline.

Other statements

If the interpreter encounters any other statement that looks like a method call with no arguments, it should pretend it's executing it. For example,

lightsoff()
gohome()

should print (together with a newline):

executing lightsoff
executing gohome

In other words, executing [Method name] should be printed. All statements will be lowercase and will consist entirely of letters.

Keywords cannot be statements. You do not have to deal with the following (it will not appear in the pseudocode): - if() - endif() - loop() - while() - etc.

However, statements that start with keywords are valid. For example, loophole() should print executing loophole, even though loop() itself is not valid.


Challenge rules

  • Your program should take a string as input. It can also take something equivalent, like an array of characters. But you can't take an array of strings; your program must itself separate the lines and tokens. You can also take a file as input.
  • Your program should print the output of the pseudocode in any reasonable form.
  • No standard loopholes.
  • There are no restrictions on what your program should do when given invalid pseudocode.
  • This is code golf. The shortest code in bytes wins.

Example output

1

A = 3
output(A) // prints 3
B = 4 + A * 2
output(B)
helloworld()
output(A + B + 1 * 3)

Should give:

3
14
executing helloworld
54

2

loop NUM from 2 to 20 // cycle through possible prime numbers
    COUNT = 0
    loop DIV from 2 to NUM // cycle through possible divisors
        if(NUM/DIV*DIV == NUM) then // if the number is exactly divisible
            COUNT = COUNT + 1
        endif
    endloop
    if (COUNT == 2) then // if number is prime
        output(NUM)
    endif
endloop

Should give:

2
3
5
7
11
13
17
19

3

Tricky cases that your interpreter should handle:

// empty comment:
//
// empty line:

    // more comment testing // ///
////

if     (3<4) then
    endoftheworld() // a statement
    ifff()
    endifnot()
    // endif in a comment doesn't count
endif
// loops can be empty:
loop I from 0 to 10
endloop
output(I) // variables are global
if(1<2)
    if(3<4) // nesting is ok
        ok()
    endif
endif
// spacing doesn't matter:
output   (2+   8   - 1   )
loop             while(2<1)
    neverhappened()
endloop

Should output:

executing endoftheworld
executing ifff
executing endifnot
10
excecuting ok
9

*Technically, once pseudocode follows rules as strict as those described here, it is arguably not pseudocode anymore. Wikipedia says it's called skeleton code.


Any suggestions?

I double-checked all the specifications, but if anything seems reasonably unclear, please let me know.

| |
\$\endgroup\$
  • \$\begingroup\$ Actually that's because the challenge is uninteresting. \$\endgroup\$ – Xwtek May 3 '18 at 2:11
  • \$\begingroup\$ @Akangka thanks for the feedback. How do you think it could be made more interesting? \$\endgroup\$ – Reinis Mazeiks May 3 '18 at 16:47
  • \$\begingroup\$ Unfortunately, there is nothing to improve. You have to find other challenge. Also, it is not pseudo-code. \$\endgroup\$ – Xwtek May 4 '18 at 3:03
  • \$\begingroup\$ @Ok, thanks. I'll try to think of something. Also, read the *note. :) \$\endgroup\$ – Reinis Mazeiks May 5 '18 at 19:39
-1
\$\begingroup\$

Common Logic Gates

Given positive integer n, make a common n-to-1 gate with fewest input, i.e. make a function f: {0,1}k ↦ {0,1} with smallest k that, for each function g: {0,1}n ↦ {0,1}, there exists {ak}, such that each element ai in the sequence map to one of 0, 1, x1, x2, x3, ..., xn, satisfying that, for each {xn}, g(x1, x2, x3, ..., xn) = f(a1, a2, a3, ..., an).

Samples:

To make a common 1-to-1 gate, your circuit must take at least 2 input:

f(A,B) = A XOR B

For a buffer gate (g = x1 ↦ x1), let A=0 and B=Input (a1 = 0, a2 = x1); for a not gate (g = x1 ↦ ¬x1) , let A=1 and B=Input (a1 = 1, a2 = x1).

Alternatively, you can use f(A,B) = A AND NOT B. For a buffer gate, let B=0 and A=Input; for a not gate, let A=1 and B=Input.

To make a common 2-to-1 gate, the circuit must take at least 4 input bits: (The two inputs are represented as a and b)

f(A,B,C,D) = ((A AND B) OR (C AND NOT B)) XOR D

(ab)
00 01 10 11 A B C D
0  0  0  1  a b 0 0
0  0  1  0  0 b a 0
0  1  1  0  a a a b
0  1  1  1  1 b a 0
1  0  0  0  1 b a 1
1  0  0  1  0 a 1 b
1  1  0  1  0 b a 1
1  1  1  0  a b 0 1

Output can be an boolean expression with reasonable logic gates, or just the output corresponding to all possible input of the n-to-1 function f (the truth table of f). If there are more than one possible functions, you can output any of them.

Shortest code in bytes win.

Code that matches the requirement:

function solve(n) { // n positive int
    var res = [], tmp=[], inmap=[], need=[];
    for (var i=1; ; i++) {
        for (var _res=0; _res<2**(2**i); _res++) {
            var valid = 1;
            for (var j=0; j<2**i; j++)
                tmp[j] = Math.floor(_res/2**j)%2;
            for (var _need=0; _need<2**(2**n); _need++) {
                for (var j=0; j<2**n; j++) 
                    need[j] = Math.floor(_need/2**j)%2;
                var valid2 = 0;
                for (var _inmap=0; _inmap<(n+2)**i; _inmap++) {
                    var valid3 = 1;
                    for (var j=0; j<i; j++) 
                        inmap[j] = Math.floor(_inmap/(n+2)**j)%(n+2) - 1;
                    for (var j=0; j<2**n; j++) {
                        var bits = 0;
                        for (var k=0; k<i; k++) {
                            if (inmap[k]==-1 || (inmap[k] && (j>>(inmap[k]-1))%2))
                                bits |= 1 << k;
                        }
                        if (tmp[bits] != need[j]) 
                            valid3 = 0;
                    }
                    valid2 |= valid3;
                }
                if (!valid2) valid = 0;
            }
            if (valid) 
                res.push (tmp.slice());
        }
        if (res.length) 
            return res[AnyNonNegativeIntegerLessThan(res.length)];
        // binary index input
    }
}

function AnyNonNegativeIntegerLessThan(x) { if(R>=x) throw ("end"); return R;}
for (R=0; ; R++) { console.log (solve(1)); }

| |
\$\endgroup\$
  • \$\begingroup\$ You don't define what an n-to-1 gate is anywhere in your question. \$\endgroup\$ – Ad Hoc Garf Hunter Mar 27 '18 at 1:00
  • \$\begingroup\$ @user202729 @user56656 n-to-1 gate means a gate with n input and 1 output. common n-to-1 logic gate mean a logic gate that can be used to replace any n-to-1 gate with some proper wiring. You can treat a logic gate as a ROM(so you can decide for each input what the output is) \$\endgroup\$ – l4m2 Mar 27 '18 at 1:15
  • \$\begingroup\$ Output gates or ROM \$\endgroup\$ – l4m2 Mar 27 '18 at 1:25
  • \$\begingroup\$ You should put the definitions in the challenge. "that can be used to replace any n-to-1 gate with some proper wiring" is still not very clear, you should define more carefully what you mean by proper wiring. \$\endgroup\$ – Ad Hoc Garf Hunter Mar 27 '18 at 3:22
  • \$\begingroup\$ I assume you mean functions g: {0,1}^n -> {0,1}, right? Why do you specify x_0 and x_-1? Shouldn't x just be a vector with indices 1,2,3,...,n? \$\endgroup\$ – flawr Mar 27 '18 at 14:07
  • \$\begingroup\$ Is {a_k} just a subset of {1,2,3,...,n}? Or can we have a_1=a_2=a_3=1 for example? \$\endgroup\$ – flawr Mar 27 '18 at 14:09
  • \$\begingroup\$ {a_k} seems not a multiset. It should be an array or say a sequence of numbers \$\endgroup\$ – l4m2 Mar 27 '18 at 14:43
  • \$\begingroup\$ So you're asking for something which outputs answers to codegolf.stackexchange.com/q/24983/194 ? \$\endgroup\$ – Peter Taylor Mar 28 '18 at 11:33
  • \$\begingroup\$ @PeterTaylor No. it requires to use NAND gate to make up one circult that do the thing. Also 24983 is a 1-of-4 (74LS153), not a 4-to-1 gate common 2-to-1 \$\endgroup\$ – l4m2 Mar 28 '18 at 12:41
  • \$\begingroup\$ (+) Any reason for downvoting? Downvoting in the sandbox indicates that the challenge is incomplete, if you don't leave a comment the OP can't know what is wrong. \$\endgroup\$ – user202729 Mar 29 '18 at 4:48
  • \$\begingroup\$ @user202729, there are already comments indicating that this question is going to attract close votes as unclear if it's posted to main in the current state. \$\endgroup\$ – Peter Taylor Mar 29 '18 at 10:59
  • \$\begingroup\$ @user56656 Are the issues fixed now? \$\endgroup\$ – user202729 Mar 31 '18 at 15:16
  • \$\begingroup\$ @flawr Are the issues fixed now? \$\endgroup\$ – user202729 Mar 31 '18 at 15:16
  • 1
    \$\begingroup\$ No I still think the explanation is quite bad and the notation is not very clear \$\endgroup\$ – flawr Mar 31 '18 at 16:15
  • \$\begingroup\$ A reference implementation is no substitute for a clear specification. The first paragraph is where you need to focus your efforts. \$\endgroup\$ – Peter Taylor Mar 31 '18 at 19:32
-1
\$\begingroup\$

Is the program 32 or 64 bits?

Assignment is simple to explain: write the shortest code you need to determine whether an executable binary program supplied as parameter is 32 or 64 bits.

If there is a different kind of bitness, you can also do for it, but is not mandatory.

What I really don't want is telling me you support other bitnesses and after I get 32 or 64 as a result.

Valid outputs for 32:

32
32bit
32bits
32 bit
32 bits

The same pattern for 64.

No accepted answer.

| |
\$\endgroup\$
  • \$\begingroup\$ I think you're missing a word somewhere in the region of "determine supplied" \$\endgroup\$ – Kamil Drakari Apr 4 '18 at 19:43
  • \$\begingroup\$ @KamilDrakari thanks. \$\endgroup\$ – sergiol Apr 4 '18 at 19:53
  • \$\begingroup\$ Executable on Windows or Linux machine? What if (... maybe ...) the program is a valid executable for both "bitness" but do different things? \$\endgroup\$ – user202729 Apr 5 '18 at 1:30
  • \$\begingroup\$ Of the output formats you allow, I think the first one will result in the shortest code in every single language. Because of this, you might as well just specify that the output should be the number 32 or the number 64. \$\endgroup\$ – Nathaniel Apr 5 '18 at 8:03
  • \$\begingroup\$ This made me wonder what to do about shell scripts, which are executable programs, but require another file to interpret them and as such aren't 32-bit or 64-bit per se. Maybe it would be best to specify "executable binary file" to not have to deal with that mess. \$\endgroup\$ – Angs Apr 5 '18 at 11:22
  • \$\begingroup\$ @Angs: Thanks. Changed. \$\endgroup\$ – sergiol Apr 5 '18 at 11:27
  • \$\begingroup\$ @user202729: I don't care. Windows, Linux, Mac, whatever, ... \$\endgroup\$ – sergiol Apr 5 '18 at 11:28
  • \$\begingroup\$ @Nathaniel: It is intentional. If you have a language feature called bitness(program) returning 32bits you do not need to waste more bytes removing the bits part! \$\endgroup\$ – sergiol Apr 5 '18 at 11:30
  • \$\begingroup\$ The word "challenge" is not really true, at least for ELF. It's absolutely trivial. \$\endgroup\$ – Peter Taylor Apr 6 '18 at 20:20
  • \$\begingroup\$ @PeterTaylor : Changed, thanks. \$\endgroup\$ – sergiol Apr 6 '18 at 21:20
  • \$\begingroup\$ The real "challenge" is to know the executable file format, so this becomes more of a puzzle than a challenge. And for puzzles, people can just copy others' solution and port to other languages. // Consider having some popular file format in the challenge itself so people don't have to look up them? \$\endgroup\$ – user202729 Apr 7 '18 at 11:19
  • \$\begingroup\$ @user202729: My initial idea was to ask only for Windows .exe files but I changed my mind because it was too limiting. Without such restrictions the question becomes multi-platform. \$\endgroup\$ – sergiol Apr 7 '18 at 11:38
-1
\$\begingroup\$

The challenge

  • Write a Discord bot with a single command, !oldest, that gives the oldest user in the server that the command that was run in.

  • Gracefully failing in DM channels is not required.

  • Assume the bot's token is this invalid token: MjM4NDk0NzU2NTIxMzc3Nzky.CunGFQ.wUILz7z6HoJzVeq6pyHPmVgQgV4.
    If the token is compressed in the program, provide instructions on how to change it so I can test it.

Sample discord.py implementation

import discord
client = discord.Client()
@client.event
async def on_message(M):
 if(M.content=="!oldest"):
  N=sorted([x.id for x in M.server.members])[1]
  await client.send_message(M.channel, str(M.server.get_member(N)))
client.run("MjM4NDk0NzU2NTIxMzc3Nzky.CunGFQ.wUILz7z6HoJzVeq6pyHPmVgQgV4")
  1. Get a list of every user in the server
  2. Sort their snowflake IDs
  3. Print the username and discriminator of the member with the smallest ID.

No API for your language? Have fun.

Standard loopholes forbidden, etc, etc.

Shortest code in bytes wins.


Sandbox

I originally posted this question on the main site, but I deleted it, as it turns out I'm bad at writing these. Please forgive me.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ I'm sure I've seen this already, but with comments saying that it needed a lot more information to be self-contained. It still needs a lot more information to be self-contained. \$\endgroup\$ – Peter Taylor May 5 '18 at 11:11
  • \$\begingroup\$ Yep. I've edited the question to clarify. \$\endgroup\$ – SIGSTACKFAULT May 5 '18 at 12:35
  • 2
    \$\begingroup\$ Are you talking about discord servers? Other than form the example this is not clear at all. What is a DM channel? What is a token in this context? \$\endgroup\$ – flawr May 5 '18 at 13:02
  • \$\begingroup\$ A: Clarify that you're talking about Discord B: When you make a challenge that requires a library does that mean I can use a library that conveniently has the command you're asking of? \$\endgroup\$ – IQuick 143 May 6 '18 at 2:12
-1
\$\begingroup\$

Divide two strings


One day, I saw the challenge to multiply two strings and I thought I might be able to do one better.

That challenge was fake. It was elementwise maximum. It was not real multiplication. So I set out to make something real. Real division between two strings.

I quickly realized that this would make an amazing challenge, as the algorithm was surprisingly complex and interesting to implement.

I then realized that it was actually easily reduced into a mere few operations. I'm still doing the challenge, though.

Enough with the backstory. Let's go.

Method

To divide two strings, do the following, where x is the first string and y the second:

  • If x does not contain y, return a space and a period concatenated to x.
    • For example, testx and blah would become .textx, with a space at the beginning.
  • Otherwise, return every occurrence of y in x, a period, then y divided by x with every occurrence of y removed, with all the periods removed.
    • For example, eestestst and est would become estest.est.

Challenge

Write a program or function that, given two strings via standard input, returns the first string divided by the second.

You may assume that neither input string contains a space, newline or period, and that the operation does not require more than 10 layers of recursion.

Test cases

test, es => es. es
test, blah =>  .test
okayye, y => yy. y
testes, es => eses. es
battat, at => atat. at
see, es =>  .see
see, e => ee. e
same, same => same. 
aabb, ab => ab.ab 
eestestst, est => estest.est
aheahahe, aheah => aheah.aheah ah

Scoring

As this is , the submission with the least amount of bytes wins.

Sandbox questions

  • Is this a duplicate?
  • Have I missed anything?
  • Does anything need further explaining?
  • Is there an issue with the concept of the challenge?
| |
\$\endgroup\$
  • \$\begingroup\$ What for aabb / ab? \$\endgroup\$ – l4m2 Jun 1 '18 at 12:42
  • \$\begingroup\$ okayye, y => yy. okay typo? \$\endgroup\$ – l4m2 Jun 1 '18 at 12:42
  • \$\begingroup\$ The test case battat, at => atat. by seems like it should be battat, at => atat. bt instead. \$\endgroup\$ – Kamil Drakari Jun 1 '18 at 13:47
  • 1
    \$\begingroup\$ It seems odd to me that when no characters are matched the output format is {matched characters (empty)}<space>.{unmatched characters} while the format when there are matches becomes {matched characters}.<space>{unmatched characters}. I would much rather see consistent ordering of the . and <space> \$\endgroup\$ – Kamil Drakari Jun 1 '18 at 13:50
  • \$\begingroup\$ @KamilDrakari 2 / 4 is 0.5, not .05, when 4 is not contained within 2 at all. Thus it makes no sense for test / blah to be . test when blah is not contained within test. We treat a space essentially like a zero would be with normal numbers. \$\endgroup\$ – LyricLy Jun 1 '18 at 22:15
  • 1
    \$\begingroup\$ @LyricLy 6/4 is 1.5 not 1.05. If you're treating space as 0 then there shouldn't be any space after the dot in any of the test cases. \$\endgroup\$ – Kamil Drakari Jun 1 '18 at 22:58
  • \$\begingroup\$ @KamilDrakari Actually, you're right. I was entirely mistaken because you get a fraction from 1 / remainder, not original number / remainder. Meaning this entire thing is wrong and I need to figure out a good replacement for 1 in string form. \$\endgroup\$ – LyricLy Jun 2 '18 at 3:32
  • \$\begingroup\$ Fixed the issues. \$\endgroup\$ – LyricLy Jun 2 '18 at 3:50
  • \$\begingroup\$ I accept downvotes, but I'd appreciate suggestions on how to improve the idea, or at least an explanation of what's wrong with it, so I know why I shouldn't post it. \$\endgroup\$ – LyricLy Jun 2 '18 at 8:18
-1
\$\begingroup\$

Introduction

I recently came across an oral exam where the candidates were asked to find a logical circuit than can negate 3 inputs A,B,C using only two NOT gates.

The question also specified that such a circuit is unique up to removal of useless gates and reordering inputs/outputs. The candidates were asked to prove this assertion by writing a piece of code that generates all such circuits.

Challenge

No inputs whatsoever are given.

The program must output all logical circuits using unlimited AND and OR gates but only two NOT gates which take in three inputs which map to three outputs. The outputs should be the negation of each input.

The outputted circuits should not have any redundant/trivial gates (gates that always output the same thing) or unused gates (whose output doesn't influence the outcome).

The program should use as little precalculated data as possible.

Output format is left up to the coders.

The winner will be determined by overall simplicity -- low run time and code elegance. It is not an objective criterion.

Example Input and Output

Input:

N/A

Output:

R    = (A & B) | (A & C) | (B & C)
notR = !R
S    = (notR & (A | B | C)) | (A & B & C)
notS = !S

notA = (notR & notS) | (notR & S & (B | C)) | (R & notS & (B & C))
notB = (notR & notS) | (notR & S & (A | C)) | (R & notS & (A & C))
notC = (notR & notS) | (notR & S & (A | B)) | (R & notS & (A & B))
| |
\$\endgroup\$
  • \$\begingroup\$ Example output and proof of existence are provided here \$\endgroup\$ – John Do Jun 17 '18 at 9:22
  • 1
    \$\begingroup\$ "It is not an objective criterion." Then it is not an on-topic question. \$\endgroup\$ – Peter Taylor Jun 19 '18 at 8:49
1
86 87
88
89 90
98

You must log in to answer this question.

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