text
stringlengths 180
608k
|
|---|
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/80786/edit).
Closed 7 years ago.
[Improve this question](/posts/80786/edit)
Here is the challenge as proposed by @trichoplax thanks to him for consolidating my post and standarizing it to PPCG common-rules.
---
* A **galaxy** is a group of numbers where each one is mapped to another via a precise function **f** either a symbolic one or mathematical, a structure of numbers sharing some common points with [this challenge i got inspired from](https://codegolf.stackexchange.com/questions/53642/every-possible-cycle-length) with an exception that a galaxy sequence is not cyclic, but holds in a **black hole**, where **more than one number** can be mapped to it.
* A black hole is a specific unique number from a galaxy where all numbers (not individually) are mapped transitively to it, by repeating a function **f** infinitely over an infinite far number in a same galaxy, or just once if a number is the closest in the same galaxy, for example if the function is the ceiling of the square root then a black hole for the biggest galaxy so far excluding only the number 1 is `2`, because mapping the closest number `3` or the infinite repetitively leads to the same number.
# Task
Conceive a universe of an **infinite** number of distinct galaxies where all galaxies encompass an **infinite** number of **integers**.
Note that the example of ceiling of square root is banned for two reasons:
* The galaxy {1} is finite.
* There is a finite number of galaxies.
A valid example, is dividing by the smallest prime factor. This gives an infinite number of infinite galaxies.
```
2*2*3*5*5*7, 2*3*5*5*7, 3*5*5*7, 5*5*7, 5*7, 7, 7*5*5*5, 7*5*5*5....
5*5*7*11, 5*7*11, 11*7*7*7... , ....
...
```
Or one galaxy as a tree:
```
2*2*5 - 2*5 \
\
2*3*5 - 3*5 - 5
3*3*5 / |
/
2*5*5 - 5*5 /
3*5*5 /
```
Each galaxy consists of all numbers that share the same largest prime factor, and the function takes them all step by step towards the black hole which is that prime factor.
Note also, you may choose any domain of integers as long as the range is infinite, i mean you can exclude a range of numbers that makes the rest still boundless like {1,0} from last example.
Your program takes any integer input via a function's dimension , STDIN, and outputs an integer as the image mapped from this preimage, otherwise prints "error" or any string prespecified for an outputless range of enteries.
For the same example:
(IN/OUTPUT)
```
20
10
15
5
77
11
0
'undefined'
1
'undefined'
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest program in bytes wins.
I would have really liked to add a bonus-score for anyone who succeeds to find a function generating a universe without trees, alas, bonuses for code-golf are excluded.
[Answer]
# Python 2, 15 bytes
```
lambda n:n>>n%2
```
The domain is nonnegative integers.
[Answer]
# Python, 40 bytes
```
lambda n:n&~-n and int(bin(n)[3:],2)or n
```
Clear the top bit if there's more than one bit set, otherwise returns the number itself. The domain is the positive integers.
First couple numbers (in binary):
```
1: 1
10: 10
11: 1
100: 100
101: 1
110: 10
111: 11
1000: 1000
1001: 1
1010: 10
1011: 11
1100: 100
1101: 101
1110: 110
1111: 111
10000: 10000
10001: 1
10010: 10
10011: 11
10100: 100
10101: 101
10110: 110
10111: 111
11000: 1000
11001: 1001
11010: 1010
11011: 1011
11100: 1100
11101: 1101
11110: 1110
11111: 1111
```
[Answer]
# Pyth, 2 bytes
```
hP
```
Domain: integers ≥ 2. Function: smallest prime factor. Black holes: primes.
(This seems too simple but seems to satisfy the challenge as far as I can tell. Is the challenge missing some requirement? For example, perhaps the function is supposed to be surjective?)
[Answer]
# Pyth, ~~5~~ 4 bytes, no trees
I am working under the assumption that the author intended for the function to be surjective, and for “no trees” to mean that only black holes have multiple preimages. (Technically, a tree with only one branch is still a tree.)
```
ahxt
```
Domain: positive integers. Function: *f*(*x*) = |((*x* − 1) XOR *x*) + 1 − *x*|. Black holes: powers of 2. Galaxies:
1 ← 3 ← 5 ← 7 ← 9 ← 11 ← ⋯,
2 ← 6 ← 10 ← 14 ← 18 ← 22 ← ⋯,
4 ← 12 ← 20 ← 28 ← 36 ← 44 ← ⋯,
8 ← 24 ← 40 ← 56 ← 72 ← 88 ← ⋯,
⋮
[Answer]
# Python 2, 29 bytes
```
lambda n:int("0"+`n`[1:])or n
```
Strips off the first digit, unless that makes the number 0. The domain is the positive integers.
[Answer]
## 05AB1E, 9 bytes
**Code:**
```
Dpiëf¬¹s/
```
**Explanation:**
```
Dpi # if input is prime return input
ë # else
f¬ # get the smallest primefactor
¹s/ # divide input by this factor
```
Domain:`{n | n∈N ∧ n>1}`
Range: `{n | n∈N ∧ n>0}`
[Answer]
## JavaScript (ES6), 12 bytes
```
n=>n%2?n:n/2
```
The domain is the positive integers. The black holes are the odd numbers.
[Answer]
# Pyth, 5 bytes
```
|stzz
```
Port of my Python answer (the decimal version).
[Answer]
## matlab (156)
```
a=input('');if find(num2str(a)=='0')a,return,end,b=char(num2str(a)-1);c=str2num(b);if find(b=='0')if(find(num2str(c)=='0')&c)c,else 10^nnz(b)+c,end,else c,end
```
* I declare my self the winner of that imaginary score because i am the first who finds a universe of galaxies without trees.
* Domain is decimal numbers with two or more significant digits. and not a difference bteween two arbitray digits squals to 9 .
* Black holes are numbers which have significant zeros, either in the extreme bottom, or between two strictly positive digits `12300131` , `123400` , `10` , ....
* The function is decrementing all decimal digits of that number by `1`, if we stumble upon a significant zero we declare a blackhole, if non-significant zero at the head of this number, precede it with `1` then the result topped by unsignificant zeos.
* There is no trees in that galaxy except the blackhole which absorbs an infinite tree-less streams of finite numbers.
] |
[Question]
[
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/11654/edit).
Closed 7 years ago.
[Improve this question](/posts/11654/edit)
For a given natural number `n`, compute the number of ways how one can express `n` as a sum of positive natural numbers. For example, for `n = 1` there is just one way. For `n = 4` we have 5 possible ways:
```
1 + 1 + 1 + 1
1 + 1 + 2
1 + 3
2 + 2
4
```
The ordering of terms in a sum doesn't matter, so `1 + 3` and `3 + 1` are considered the same. Your program should be effective enough to return the result for `n = 1000` in order of minutes.
The winner will the solution with most up-votes in (at least) 2 weeks.
[Answer]
# Haskell, 170 148
An efficient Haskell version using a generating function with Memoization. Solve instantaneously the problem for `n = 1000`. No precision issues even with large numbers:
```
time ./partitions 10000
36167251325636293988820471890953695495016030339315650422081868605887952568754066420592310556052906916435144
./partitions 10000 17.02s user 0.00s system 100% cpu 17.021 total
```
## The code
```
generalizedPentagonal = map pentagonal $ [1..] >>= \i->[i,-i]
where pentagonal n = (3*n^2-n)`quot`2
partitions = (map partitions' [0..] !!)
where partitions' 0 = 1
partitions' n = sum . alternate . map partitions . takeWhile (>=0) . map (n-) $ generalizedPentagonal
alternate = zipWith (*) (concat . repeat $ [1,1,-1,-1])
```
## Code-golf version
```
p=(map a[0..]!!)where a 0=1;a n=sum.zipWith(*)(concat.repeat$[1,1,-1,-1]).map p.takeWhile(>=0).map(n-).map(\n->(3*n^2-n)`quot`2)$[1..]>>= \i->[i,-i]
```
## Efficiency improvements
Replace the memoization with an `Array` instead of a list:
```
import Data.Array
[...]
bnd = (0,10000)
partitions = (array bnd [(i, partitions' i) | i <- range bnd] !)
[...]
```
Time for `partitions 10000` drop from `17s` to `960ms`
## Results
Interpreted:
```
partitions 1000
24061467864032622473692149727991
(0.11 secs, 21833064 bytes)
```
Compiled:
```
time ./partitions 1000
24061467864032622473692149727991
./partitions 1000 0.08s user 0.00s system 99% cpu 0.084 total
```
## Useful links
* [The generating function](https://en.wikipedia.org/wiki/Partition_%28number_theory%29#Generating_function)
* [Generalized pentagonal numbers](https://en.wikipedia.org/wiki/Pentagonal_number)
[Answer]
**Mathematica ~~25~~ 11**
```
PartitionsP
```
Usage
```
PartitionsP[4]
(*
5
*)
```
Calculating the result for n = 1000 is instantaneous
```
Timing[PartitionsP@1000]
(*
{0., 24061467864032622473692149727991}
*)
```
[Answer]
## JavaScript
```
var partition = function(n) {
var sigma=[], p=[1], i,j;
for (i=1; i<=n; i++)
for (j=i; j<=n; j+=i)
sigma[j] = (sigma[j]||0) + i;
for (i=1; i<=n; i++) {
p[i] = 0;
for (j=1; j<=i; j++)
p[i] += p[i-j] * sigma[j];
p[i] /= i;
}
return p[n];
}
```
This computes the partition function [A000041](http://oeis.org/A000041) as the Euler transform of the sequence [A000012](http://oeis.org/A000012) (1,1,1,...). The intermediate sequence `sigma` is [A000203](http://oeis.org/A000203), the sum-of-divisors function.
For `n=1000` it takes approx 0.05 seconds in Node on my 2GHz machine, although since it's working with JS numbers it runs into precision issues. A slightly more complex version ([online demo](http://jsfiddle.net/AVE8y/), it's a bit long to paste) adds a naïve big integer implementation and takes approx 0.5s in Node.
[Answer]
# JavaScript, 105 103
```
for(n=prompt(a=[b=1]);b<=n;a[b++]=s)for(s=0,k=1,j=b-1;j>-1;j-=k&1?k:k/2)s+=++k&2?a[j]:-a[j];alert(a[n])
```
Calculation takes less than 250ms for n=1000. The result isn't precise, because JS doesn't have arbitrary precision numbers, but the order of the result is correct.
[Answer]
## GolfScript, table recurrence
```
[[1]]\({..[[{1$,1$,-=}%0@0=+]zip{{+}*}:^%]\+}*0=^
```
Assumes input as an integer on the stack: leaves the result on the stack. [Online demo](http://golfscript.apphb.com/?c=MTAKW1sxXV1cKHsuLltbezEkLDEkLC09fSUwQDA9K116aXB7eyt9Kn06XiVdXCt9KjA9Xg%3D%3D) counting partitions of `10`.
This isn't as efficient as the other answers (it computes the partitions of 1000 in approximately 30 seconds), but the mathematical background is much simpler.
Instead of considering just the number of partitions of `n`, consider the number of partitions of `n` into `k` parts: `p(n, k)`. Each such partition either contains a `1` or doesn't. The number of partitions which contain a `1` is easily seen to be the same as the number of partitions of `n-1` into `k-1` parts. For the partitions which don't contain a `1`, we can subtract `1` from each part without getting any zeroes, so their number is equal to the number of partitions of `n-k` into `k` parts. So we have the recurrence `p(n, k) = p(n-1, k-1) + p(n-k, k)`.
This program builds the table of `p(n, k)` starting from `p(1, 1) = 1`, and then at the end adds up the partitions of `n` into `1..n` parts to get the result.
Dissection:
```
# Initialise the table p(x,k) with the row for x=1
# Note that we will prepend new rows to the table, so it is built backwards
[[1]]
# Repeat n-1 times
\({
# We need a couple of copies for the two parts of the sum in the recurrence
..
# Collect in an array...
[
# Collect in an array...
[
# First an array of p(x-k, k) for k = 1 to x-1
# x is the length of the current table plus one
# We iterate over the rows of the table
{
# Stack: table table row
# Row x-k is of length x-k, so k = x - length(row)
# But because the row is indexed from 0, we want to find k - 1
# = length(table) - length(row)
1$,1$,-
=
}%
# Stack: table table [p(x-1,1) ... p(1,x-1)]
# (Although actually it will be shorter, only until about p(x/2, x/2))
0@0=+
]
# Stack: table [[p(x-1,1) ... p(1,x-1)] [0 p(x-1,1) ... p(x-1,x-1)]]
# Vector sum. Note that we store the array-sum operation in ^ for later use.
zip{{+}*}:^%
]
# Prepend to the table
\+
}*
# Take the first row of the table and sum it
0=^
```
(NB If this were [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") then I would save 1 char by repeating the loop `n` times and taking the second row of the table at the end).
[Answer]
# Python2, 110 (Bruteforce O(n^n) implementation)
A bruteforce implementation in python which takes the input of stdin:
```
from itertools import*
n=input()
print len(set(frozenset(p)for p in product(range(n+1),repeat=n)if sum(p)==n))
```
Computing the result for n=8 takes 10 seconds on my machine. Anything over that is way over a few minutes.
[Answer]
### GolfScript
```
2,\.,{[2+.2&(0@,{.2%!)/+}/]}%`{0\{~.4$,<*~)3$=*+}/+}+*-1=
```
Just because we need a GolfScript entry. Thanks to Peter for several ideas.
*Example:*
```
1000 2,\.,{[2+.2&(0@,{.2%!)/+}/]}%`{0\{~.4$,<*~)3$=*+}/+}+*-1=
# => 24061467864032622473692149727991
```
[Answer]
## JavaScript Hardy-Ramanujan-Rademacher
This depends on [a BigNumber implementation](https://github.com/MikeMcl/bignumber.js/blob/v1.0.1/bignumber.js) which supports the following functions: `plus`, `minus`, `times`, `div`, `sqrt`, `isZero`, `lt`, `gt`, `round`). It also uses `config` to control the precision used in divisions and to set the rounding mode.
```
var partition = function(n) {
// Hardy-Ramanujan estimate to set the precision with appropriate margin
BigNumber.config((5 + 1.115 * Math.sqrt(n) + Math.log(n) / Math.log(100))|0, 6);
// Hardy-Ramanujan-Rademacher
var zero = new BigNumber(0),
one = new BigNumber(1),
// \sum_{i=0}^\infty 2^{i+1} i!^2 / {2i+1}!
PI = function(){ var t = new BigNumber(2), s=t, i=1; while (!t.isZero()) s = s.plus(t = t.times(i).div((i+ ++i))); return s }(),
A = new BigNumber(n).minus(one.div(24)),
B = A.times(2).div(3).sqrt().times(PI),
ABsqrt12 = A.times(B).times(new BigNumber(12).sqrt()),
gcd = function(x, y) { return y ? gcd(y, x % y) : x },
genexp = function(x, a, b, c, d) {
// \sum_{i=0}^\infty ax^{4i}/(4i)! + bx^{4i+1}/(4i+1)! + cx^{4i+2}/(4i+2)! + dx^{4i+3}/(4i+3)!
var res = zero, z = one, i;
for (i=0; !z.isZero(); i+=4) {
res = res.plus(z.times(a)); z = z.times(x).div(i+1);
res = res.plus(z.times(b)); z = z.times(x).div(i+2);
res = res.plus(z.times(c)); z = z.times(x).div(i+3);
res = res.plus(z.times(d)); z = z.times(x).div(i+4);
}
return res;
},
p = zero, q = 0, C, L, Psi_, h, k, s, max_L = zero;
for (;;) {
// Adaptive precision calculation for performance
if (++q > 1) BigNumber.config((5 + 1.115 * Math.sqrt(n) / q + Math.log(n) / Math.log(100))|0);
L = zero;
for (h = 0; h < q; h++) {
if (gcd(h,q) > 1) continue;
for (k=s=0; k < q; k++) s+= (2*(h*k %q) - q) * k - 4*h*n;
// NB The %(4*q*q) is critical for performance
L = L.plus(genexp(new BigNumber(s % (4*q*q)).div(2*q*q).times(PI),1,0,-1,0));
}
if (L.gt(max_L)) max_L = L;
C = B.div(q);
Psi_ = genexp(C,C,-1,C,-1).times(new BigNumber(q).sqrt());
p = p.plus(L.times(Psi_));
if (Psi_.times(max_L).abs().lt(ABsqrt12)) break;
}
return p.div(ABsqrt12).round();
};
```
It computes `partition(10000)` in about 0.67 seconds using Node on a 3.5GHz PC.
] |
[Question]
[
Write a program which outputs the square root of a given number in the shortest time possible.
## Rules
It may not use any builtins or powering with non-integers.
# Input format
* as a function argument
* as a command line argument
* as a direct input on stdin or a window
Your entry hasn't to be a complete program, it may be a function or a snippet.
It doesn't need to be exact; a one percent margin of error is allowed.
The test cases will only be positive integers, but your program should output/return floats.
It may return the square root as function return value, print it to stdout or write in a consistent file, which is readable by the user..
Each program should specify the compiler/interpreter it should be run on and compiler flags. If they aren't specified, I'll use the following implementations: (just talking about mainstream langs):
* C/C++: gcc/g++ on Linux, no flags
* Java: OpenJDK on Linux, no flags
* Python: CPython
* Ruby: MRI
* Assembler: x86 Linux
* JS: Node.js
## Examples
```
Input Output
4 2 (or something between 1.98 and 2.02)
64 8 (between 7.92 and 8.08)
10000 100 (between 99 and 101)
2 bewteen 1.40001 and 1.428
```
## Scoring
Your programs on the same computer with same conditions (Terminal and Iceweasel with this tab open).
This question has the tag "Fastest code", so the program, which calculates the square root of a (not yet given) random integer between 1 and 10^10 as fast as possible will win!
[Answer]
# C
Since input is limited to positive integers between 1 and 1010, I can use a well-known fast inverse square root [algorithm](https://en.wikipedia.org/wiki/Fast_inverse_square_root) to find the inverse square root of the reciprocal of the input.
I'm not sure what you mean by *"only Xfce and the program and a terminal running"* but since you stated that functions are acceptable, I provide a function in C that will take an integer argument (that will be casted to float automatically) and outputs a float as the result.
```
float f(float n) {
n = 1.0f / n;
long i;
float x, y;
x = n * 0.5f;
y = n;
i = *(long *)&y;
i = 0x5f3759df - (i >> 1);
y = *(float *)&i;
y = y * (1.5f - (x * y * y));
return y;
}
```
The following is a program that makes uses of the function above to calculate the square roots of the given test cases and compares them to the values given by the `sqrtf` function in `math.h`.
[Ideone](http://ideone.com/xhpvud)
[Answer]
# Python 3
Why am I using Python? Never mind.
```
def sqrt(n):
# 3 iterations of newton's method, hard-coded
# normalize
# find highest bit
highest = 1
sqrt_highest = 1
while highest < n:
highest <<= 2
sqrt_highest <<= 1
n /= highest+0.0
result = (n/4) + 1
result = (result/2) + (n/(result*2))
result = (result/2) + (n/(result*2))
return result*sqrt_highest
```
[Ideone it!](http://ideone.com/fq8Do0)
[Answer]
# C
Uses unsigned integers when possible for speed.
`root.c`:
```
#include <math.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define ns(t) (1000000000 * t.tv_sec + t.tv_nsec)
struct timespec then, now;
int output(uint64_t result)
{
clock_gettime(CLOCK_REALTIME, &now);
printf("sqrt(x) = %10lu.%2d real time:%9ld ns\n", result / 100, ((int) (result % 100)), ns(now) - ns(then));
return 0;
}
//real time: 60597 ns
int main(int argc, char *argv[]) {
clock_gettime(CLOCK_REALTIME, &then);
uint64_t num = atol(argv[1]), root = 100, old_root = 0;
num *= 10000; //multiply by 10k because int is faster
//and you only need 2 d.p. precision max. (for small numbers)
while (old_root != root) {
old_root = root;
root = (root + num / root) / 2;
}
return output(root);
}
```
`timein`:
```
#!/bin/bash
gcc -Wall $1 -lm -o $2 $2.c
./$2 $4
r=$(seq 1 $3)
for i in $r; do ./$2 $4; done > times
awk -v it=$3 '{ sum += $7 } END { print "\n" sum / (it) " ns" }' times
rm times
```
Usage: `./timein '-march=native -O3' root <iterations> <number>`
Inspired by [this answer](https://codegolf.stackexchange.com/a/74372/39244), uses [this algorithm](https://en.wikipedia.org/wiki/Newton's_method).
[Answer]
# [C (gcc)](https://gcc.gnu.org/)
demonstrates one Newton step after a linear approximation on mantissa
speed of C is fast but not really relevant unless you have to apply it several million times
then it is sensitive to overall context of SIMD vectorisation, memory access patterns & other branching causing pipeline stalls etc
```
float f(float x){int i=*(int*)&x;i=0x1fb90000+(i>>1);float y=*(float*)&i;return(y+x/y)/2;}
void main() {float y[4]={4,64,10000,2};
for(int j=0;j<4;j++)printf("f(%f)\t=\t%f\n",y[j],f(y[j]));}
```
[TIO](https://tio.run/##LY1BboMwEEX3nMJKlcoGim1qWlHHXCRkkQITjAgg41QgxNmpaTqbNxq9/6d4uxXF9qK7on2UFTqNttR9VGce9dFYVai2dviitOZijIbERL250ZjxmLKUsimB988kLSGq7b1FPt2g7a8WAX5yIovuLNLKx44@eZ2kVmzi8J0yNwHWWcaJfMqzs/4252lpKvswHZ6Dic6ExnL1fnpdovtVd5ig5T9yFhe1iPBDhHwvDONVetCb/RtqFJPNScgmCMhg3AXwAfARSG5Vbo@Qd4dwPjeXEPAOQuS6bb8 "C (gcc) – TIO")
[Answer]
>
> Adaptation of [my own answer](https://codegolf.stackexchange.com/questions/9027/fast-inverse-square-root/145914#145914) on [Fast inverse square root](https://codegolf.stackexchange.com/questions/9027/fast-inverse-square-root)
>
>
>
# [Tcl](http://tcl.tk/), 114 bytes
```
rename binary B
proc R n {B s [B f f $n] i i
B s [B f i [expr 0x5f3759df-($i>>1)]] f y
expr 1/($y*1.5-$n/2*$y**3)}
```
[Try it online!](https://tio.run/##PYm7CoMwAEV3v@IOGaJgNT5aOtTBT7CjZLA2QkDTNFpIEL89DR167nK4Zxtn741QwyLwkGowDm2kzWtEB4W9xYq@xRRGFIeEjP6XRC@sNshtPZWX@vqcUkpk07CY85Bd9Ksso8Ql7FSnRGVFEjwp48PPy6BhsVc4V2B5AMWBXX@2Ffe3ocTGt74DsfzwXw "Tcl – Try It Online")
] |
[Question]
[
In this challenge, you will take an input image and crop it to make a square, leaving only the central part of the input image.
The answers must work with landscape, portrait, or square input images. The width of the output image should be equal to the shortest side of the input image e.g. the result of a 200x300 image should be a 200x200 image. An equal amount must be cropped from both ends of the input image e.g. for a 200x300 input image, 50 pixels should be cropped from each end of the image, leaving only the central part of the image. Where its not possible to crop an equal amount from both sides e.g. a 200x301 image, the extra 1 pixel may be cropped from either end of the image. For a square input image, the output should be identical to the input.
**Input:**
The input file should be read from the hard disk of the machine running the program. You may choose which of bmp, jpeg, png or [pnm](http://en.wikipedia.org/wiki/Portable_anymap) to support as the input image format.
**Output**
The output file should be written to the hard disk of the machine running the program. The format of the output image should be bmp, jpeg, png or [pnm](http://en.wikipedia.org/wiki/Portable_anymap).
**Win Criteria**
This is code golf. Shortest code wins.
**Notes:**
1. The input/output file paths do not count towards the program size.
2. The standard libraries of your programming language may be used. Other libraries are disallowed.
3. [Standard loopholes apply](http://meta.codegolf.stackexchange.com/questions/1061/standard-loopholes-which-are-no-longer-funny).
**Example:**
Input Image:
Expected Output:
Images by kirill777 - licenced CC-BY 3.0
[Answer]
# Parsing the raw bytestream: Haskell (319 = 332 - 13)
Without any imports at all, this program crops P1 PBM images.
```
g _[]=[]
g z x=(\(a,b)->a:g z b).splitAt z$x
q=map
f=filter
main=do c<-readFile"in.pbm";let(r:p)=tail.f((/='#').head).lines$c;(w:h:_)=(q read).words$r;m=min w h;t s=take m.drop((s-m)`div`2);k d=[[m,m]]++(q(t w)(t h d))in writeFile"out.pbm".("P1\n"++).unlines.q(unwords.(q show)).k.(q((q read).g 1)).take h.g w.f(`elem`"01").concat$p
```
## Special case: helpful formatting (214 = 227 - 13)
My first attempt at PBM (P1) was based on the example at Wikipedia and assumed spaces separated the pixels, and lines in the text correlated with lines in the image. Under those conditions, this shorter version works fine.
```
main=do c<-readFile"in.pbm";writeFile"out.pbm".("P1\n"++).unlines.q(unwords.(q show)).k.q((q read).words).tail.filter((/='#').head).lines$c
k((w:h:_):d)=let m=min w h;t s=take m.drop((s-m)`div`2)in[[m,m]]++(q(t w)(t h d))
q=map
```
Bonus feature: strips out comments!
Both of the above work in essentially the same manner as the original below, but with a simpler header, lower bit depth, and no padding, although the topmost program works harder to allow for a range of formatting options.
# Also available in a wide range of colours: Haskell (545 = 558 - 13)
No pre-existing image-handling functions were harmed in the making of this program.
Uncompressed 24-bit RGB bitmaps have a fairly straight-forward header system but are complicated by the mod-4 padding for each row's byte array. This code grabs the bitmap offset, width, and height from the input header, calculates the row padding, and extracts the bitmap data into a list of lists (rows of columns, bottom-left corner first).
Cropping is as simple as dropping half the excess and then taking the desired length from each list. The new file size is calculated as 3\*(padded width)\*height + 54 bytes (for the minimal required headers). The new header is constructed and the cropped image data appended. It's all mapped to characters and written back out to disk.
Input: `in.bmp` (6 characters removed from total)
Output: `out.bmp` (7 characters removed from total)
I think there's still some redundancy still in there, but my brain hurts to look at it this way.
```
import System.IO
import Data.Char
import Data.List.Split
main=do k"in.bmp"ReadMode(\h->do i h u;c<-hGetContents h;let d=l(ord)c;w=s 18d;h=s 22d;p=o w;m=min w h;q=o m;j a b=y a(r b m)in k"out.bmp"WriteMode(\g->do i g u;hPutStr g$"BM"++l chr((z e[m*(3*m+q)+54,0,54,40,m,m,1572865,0,0,1,1,0,0])++((z((++(f q$cycle[0])).y(3*m)(3*r w m)).j m h$chunksOf(3*w+p)$n(s 10d)d)))))
i=hSetBinaryMode
k=withFile
z=concatMap
l=map
v=div
f=take
n=drop
u=True
y t d=f t.n d
s d=sum.zipWith(*)(l(256^)[0..3]).y 4d
o=(`mod`4)
r a b=v(a-b)2
e x=l((`mod`256).(x`v`).(256^))[0..3]
```
For comparison, an ungolfed version is over 8 times as long, at 4582 (4595 - 13) bytes:
```
import System.IO
import Data.Char
import Data.List.Split
main = readImage cropImageToSquare
cropImageToSquare fileHandle = do
hSetBinaryMode fileHandle True
fileContents <- hGetContents fileHandle
let
inImageData = asBytes fileContents
inImageBitmapOffset = getIntFromWordAt 10 inImageData
inImageWidth = getIntFromWordAt 18 inImageData
inImageHeight = getIntFromWordAt 22 inImageData
inImageBitmapData = drop inImageBitmapOffset inImageData
inImageBitmap = chunksOf (paddedBytesForWidth inImageWidth) inImageBitmapData
outImageSideLength = min inImageWidth inImageHeight
outFileHeader = fileHeader outImageSideLength outImageSideLength
outImageHeader = imageHeader outImageSideLength outImageSideLength
outHeaders = outFileHeader ++ outImageHeader
outImageBitmap = crop outImageSideLength outImageSideLength inImageWidth inImageBitmap
in
writeImage "out.bmp" outHeaders outImageBitmap
--- Read Image ---------------------------------------------------------
readImage = withFile "in.bmp" ReadMode
--------------------------------------------------------- Read Image ---
--- Write Image --------------------------------------------------------
writeImage filename header imageBitmap = do
withFile filename WriteMode write'
where
write' fileHandle = do
hSetBinaryMode fileHandle True
hPutStr fileHandle . ("BM"++)
. map chr $ (concatMap wordFromInt header)
++ (concat imageBitmap)
-------------------------------------------------------- Write Image ---
--- Character-Integer Conversion ---------------------------------------
asBytes = map ord
getWordAt offset = take 4 . drop offset
getIntFromWordAt offset = intFromWord . getWordAt offset
intFromWord = sum . zipWith (*) (map (256^) [0..3])
wordFromInt int = map((`mod` 256) . (int `div`) . (256^)) [0..3]
--------------------------------------- Character-Integer Conversion ---
--- Headers ------------------------------------------------------------
fileHeader width height = [ fileSize
, reserved
, bitmapOffset
]
where
fileSize = imageFileSize width height
reserved = 0
bitmapOffset = 54
imageFileSize width height = 54 + height * (paddedBytesForWidth width)
paddedBytesForWidth width = 3 * width + rowPadding width
rowPadding = (`mod` 4)
imageHeader width height = [ imageHeaderSize
, width
, height
, planesAndBits
, compression
, bitmapSize
, horizontalImageResolution
, verticalImageResolution
, paletteSize
, coloursUsed
]
where
imageHeaderSize = 40
planesAndBits = int32FromInt16s colourPlanes bitDepth
colourPlanes = 1
bitDepth = 24
compression = 0
bitmapSize = 0
horizontalImageResolution = pixelsPerMetreFromDPI 72
verticalImageResolution = pixelsPerMetreFromDPI 72
paletteSize = 0
coloursUsed = 0
pixelsPerMetreFromDPI = round . (* (100/2.54))
int32FromInt16s lowBytes highBytes = lowBytes + shift 2 highBytes
shift bytesUp number = (256 ^ bytesUp) * number
------------------------------------------------------------ Headers ---
--- Crop Image ---------------------------------------------------------
crop toHeight toWidth fromWidth = cropWidth toWidth fromWidth
. cropHeight toHeight
cropHeight toHeight image = take toHeight
. drop ( halfExtra (length image) toHeight)
$ image
cropWidth toWidth fromWidth image = map ( padRow toWidth
. take (3 * toWidth)
. drop (3 * (halfExtra fromWidth toWidth))
)
$ image
padRow toWidth xs = take (paddedBytesForWidth toWidth)
$ xs ++ (repeat 0)
halfExtra fromLength toLength = (fromLength - toLength) `div` 2
--------------------------------------------------------- Crop Image ---
```
[Answer]
## Mathematica 52
Spaces not needed:
```
ImageCrop[#, {#, #} &@Min@ImageDimensions@#] &@Import@"c:\\test.png"
```
[Answer]
# Rebol, ~~165~~ 92 (105 - 13)
```
i: load %in.bmp
s: i/size
m: min s/1 s/2
c: to-pair reduce[m m]save %out.bmp copy/part skip i s - c / 2 c
```
At its simplest if you have a image file (*in.bmp*) of 300x200 then it can be cropped and saved to file (*out.bmp*) like so:
```
save %out.bmp copy/part skip load %in.bmp 50x0 200x200
```
Rebol comes with a spatial coordinates datatype called [`Pair!`](http://www.rebol.com/r3/docs/datatypes/pair.html) Here are some examples of this datatype (using Rebol console):
```
>> type? 300x200
== pair!
>> first 300x200
== 300.0
>> second 300x200
== 200.0
>> 300x200 - 200x200
== 100x0
>> 300x200 - 200x200 / 2
== 50x0
```
The last example shows how the [`skip`](http://www.rebol.com/r3/docs/functions/skip.html) coordinates were worked out for balanced cropping.
NB. This solution was tested using latest version of Rebol 3 (see <http://rebolsource.net/>) on OS X. BMP is currently supported on all platforms. PNG, Jpeg & other formats are only partially implemented (across platforms) at this time.
[Answer]
# C# - ~~250~~ ~~271~~ ~~265~~ 229 (incl. 26 for file names)
Forgot about the import for it to work.
```
using System.Drawing;
class P{static void Main(string[] a){var b=new Bitmap(@"C:\Dev\q.jpg",true);int h=b.Height,w=b.Width,s=h<w?h:w,d=(h-w)/2;b.Clone(new Rectangle(d>0?0:d*-1,d>0?d:0,s,s),b.PixelFormat).Save(@"C:\Dev\q2.jpg");}}
```
De-golfed (or what you call it).
```
using System.Drawing;
class Program
{
static void Main(string[] a)
{
var b = new Bitmap(@"C:\Dev\q.jpg",true);
int h=b.Heightw=b.Width,s=h<w?h:w,d=(h-w)/2;
b.Clone(new Rectangle(d>0?0:d*-1,d>0?d:0,s,s),b.PixelFormat).Save(@"C:\Dev\q2.jpg");
}
}
```
Thanks (again) to w0lf for pointing out different declaration style.
[Answer]
# Java, ~~373~~ ~~348~~ ~~342~~ ~~336~~ 322
```
import java.awt.image.*;import java.io.*;import javax.imageio.*;class M{public static void main(String[]a)throws Exception{BufferedImage i=ImageIO.read(new File(a[0]));int[]d={i.getWidth(),i.getHeight()},o={0,0};int s=d[0]>d[1]?1:0;o[1-s]=(d[1-s]-d[s])/2;ImageIO.write(i.getSubimage(o[0],o[1],d[s],d[s]),"bmp",new File("out.bmp"));}}
```
Ungolfed:
```
import java.awt.image.*;
import java.io.*;
import javax.imageio.*;
class M{
public static void main(String[] args) throws Exception{
// read file as argument, instead of args[0] the path to the file could hardcoded.
// Since the path to the input file don't count towards the character count, I'm not counting args[0]
BufferedImage i = ImageIO.read(new File(args[0]));
int[] dimension = { i.getWidth(), i.getHeight() }, origin = { 0, 0 };
int smaller = dimension[0] > dimension[1] ? 1 : 0;
// 1-smaller is the index of the bigger dimension
origin[1-smaller] = (dimension[1-smaller] - dimension[smaller]) / 2;
// again, path to output file don't count
ImageIO.write(i.getSubimage(origin[0], origin[1], dimension[smaller], dimension[smaller]), "bmp", new File("out.bmp"));
}
}
```
Usage: `java M image.type`
Should be able to read jpg, png, bmp, wbmp and gif. Writes a bmp called "o".
Who said you couldn't use Java for golf?
Edit: Just realised that file paths don't count towards the character count.
[Answer]
# Bash, 115
with ImageMagic, hard to say if you can count it as a standard lib :)
```
#!/bin/bash
convert $1 -set option:size '%[fx:min(h,w)]x%[fx:min(h,w)]' xc:red +swap -gravity center -composite _$1
```
[Answer]
# Clojure, 320 (333 - 13 for filenames)
Deciding to sidestep types, this P1 (ASCII) PBM cropper is written in Clojure.
With function names like `interpose`, `read-string`, and `clojure.string/replace`, it's not exactly golf friendly, and I'm not sufficiently experienced to know if I can compile without a namespace declaration. (Leiningen puts it in automatically, and Leiningen is nice to me, so I'm going to leave it there, though I did eject `.core`.) On the plus side, however, file access and string concatenation are short.
```
(ns a(:gen-class))(defn -main[](let[[[_ r p]](re-seq
#"(^\s*\d+\s+\d+)([\s\S]*$)"(clojure.string/replace(slurp"in.pbm")#"(P1)|(#.*\n)"""))[w
h](map read-string(re-seq #"\d+"r))c(min w h)](spit"out.pbm"(apply
str"P1\n"c" "c"\n"(flatten(interpose"\n"(take
c(partition c w(drop(+(*(quot(- h c)2)w)(quot(- w c)2))(re-seq #"\S"p))))))))))
```
The function at the heart of the program is ungolfed below.
```
(defn crop-pbm [in out]
(let [ filestream (slurp in)
image-data (clojure.string/replace (str filestream "\n") #"(P1)|(#.*\n)" "")
[[_ resolution pixels]] (re-seq #"(^\s*\d+\s+\d+)([\s\S]*$)" image-data)
pixels (re-seq #"\S" pixels)
[width height] (map read-string (re-seq #"\d+" resolution))
crop (min width height)
drop-width (- width crop)
drop-height (- height crop)
initial-drop-width (quot drop-width 2)
initial-drop-height (quot drop-height 2)
initial-drop (+ (* initial-drop-height width) initial-drop-width)
cropped-pixels (take crop
(partition crop width
(drop initial-drop pixels)))
cropped-image (apply str "P1\n" crop " " crop "\n"
(flatten (interpose "\n" cropped-pixels)))]
(spit out cropped-image)))
```
Rather than constructing a two-dimensional array to represent the image, this program calculates the number of pixels to the new top-left corner and drops them, then jumps original-width pixels at a time, taking cropped-side-length pixels from as many steps.
The regular expression function `re-seq` does much of the heavy lifting, stripping out whitespace and forming arrays simultaneously, which leads me to suspect that Perl could follow this approach and yield a shorter program.
[Answer]
# Perl, 276 ~~287~~ (289 ~~300~~ - 13)
## Regex to the Rescue!
Who needs dedicated image functions when you have regular expressions? (And 1-bit images to crop.)
```
local$/;open I,"in.pbm";$_=<I>;s/(P1)|(#.*\n)//g;/^\s*(\d+)\s+(\d+)([\s\S]*)$/;($w,$h,$_)=($1,$2,$3);$c=$w<$h?$w:$h;s/\D//g;$d=$w-$c;while($z++<$w*int(($h-$c)/2)+int($d/2)){s/^\d//};while($i++<$c){/^(\d{$c})(\d{$d})(.*)/;$p.=$1."\n";$_=$3."0"x$w}open O,'>',"out.pbm";print O"P1\n$c $c\n$p"
```
That's the golfed version of:
```
use strict;
use warnings;
# Read in the image file
local $/ = undef;
open IMAGEIN, '<', "in.pbm" or die "Can't read 'in.pbm': $!";
my $image_data = <IMAGEIN>;
close IMAGEIN;
# Remove the header and any comments
$_ = $image_data;
s/(P1)|(#.*\n)//g;
# Divide into width, height, and pixels
/^\s*(\d+)\s+(\d+)([\s\S]*)$/;
(my $width, my $height, $_) = ($1, $2, $3);
# Remove anything that isn't a number from the pixel data
s/\D//g;
my $pixels = $_;
# Determine the new dimensions
my $crop = $width < $height ? $width : $height;
# Calculate total to remove along each axis
my $drop_width = $width - $crop;
my $drop_height = $height - $crop;
# Calculate how much to remove from the first side along each axis
my $initial_drop_width = int($drop_width / 2);
my $initial_drop_height = int($drop_height / 2);
# Calculate total pixels to the new top-left corner
my $initial_drop = $width * $initial_drop_height + $initial_drop_width;
# Remove the pixels preceding the corner
$_ = $pixels;
while (32760 < $initial_drop) # Stay under regex limit
{
s/^\d{32760}//;
$initial_drop -= 32760;
}
s/^\d{$initial_drop}//;
# Take *crop* rows of *crop* pixels
$pixels = "";
for (my $i=0; $i<$crop; $i++)
{
/^(\d{$crop})(\d{$drop_width})(.*)/;
$pixels .= $1 . "\n";
$_ = $3 . "0"x$width; # Add some 0s to ensure final match
}
# Construct the new, cropped image
my $cropped_image = "P1\n$crop $crop\n$pixels";
# Write out the image file
open IMAGEOUT, '>', "out.pbm" or die "Can't write 'out.pbm': $!";
print IMAGEOUT $cropped_image;
close IMAGEOUT;
```
There's a limit to the length of a string the substitution functions will handle, which necessitates a bothersome `while` loop for taller images. Even so, finally under 300!
[Answer]
# C#, 420
If the image is portrait it gets rotated while cropping and then cropped image is rotated to correct orientation.
Edit: now crop centre of the image. Run in terminal as `crop.exe a.jpg`
```
class P
{
static void Main(string[] a)
{
if (a.Length > 0)
{
Bitmap b = (Bitmap)Image.FromFile(a[0]);
int w = b.Width;
int h = b.Height;
int d = Math.Abs(w - h) / 2;
if (h > w) { b.RotateFlip(RotateFlipType.Rotate270FlipNone); }
Bitmap c = new Bitmap(h, h);
for (int x = d; x < (h+d); x++)
{
for (int y = 0; y < h; y++)
{
c.SetPixel(x-d, y, b.GetPixel(x, y));
}
}
if (h > w) { c.RotateFlip(RotateFlipType.Rotate90FlipNone); }
c.Save("Q.jpg");
}
}
}
```
[Answer]
# C++/Qt 146
This might technically break rule #2 as Qt is not part of standard C++.
The first argument will be the input filename and the second will be the output filename.
```
#include<QtGui>
main(int c,char**v){QApplication a(c,v);QPixmap p(v[1]);int w=p.width(),h=p.height(),m=qMin(w,h);p.copy(w-m,h-m,m,m).save(v[2]);}
```
[Answer]
# Io, 103 bytes (excluding file path)
```
i := Image open("img.png");e := (i width) min(i height);i crop(((i width)-e)/2,((i height)-e)/2,e,e) save("crop.png")
```
*You can* use Io for CG!
[Answer]
# Matlab, 116 (130 with file names)
Pretty straightforward.
```
I=imread('a.jpg');[m,n]=size(I);z=min(m,n);c=m<n;r=[1,ceil((m-z)/2)]*~c+c*[ceil((n-z)/2),1];imwrite(imcrop(I,[r,z-1,z-1]),'z.jpg')
```
[Answer]
# [APL (dzaima/APL)](https://github.com/dzaima/APL), 66 bytes
```
i←P5.img p
P5.size←2⍴a←⌊/s←i.sz
P5.draw←{i P5.G.img⍨.5×a-s⋄i.save}
```
[Try it online!](https://tio.run/##SyzI0U2pSszMTfz/P/NR24QAU73M3HSFAi4gozizKhUoZPSod0sikH7U06VfDKQz9YqrQNIpRYnlQG51pgKQ4w7S9qh3hZ7p4emJusWPuluAyhLLUmv//wcA "APL (dzaima/APL) – Try It Online")
] |
[Question]
[
Ok, so the input here is going to be a .csv file and so is the output. Now, given a .csv file/input like so
```
"apple","banana","apple,banana","orange"
"grape","orange","grape,orange","sprout"
# 0 1 2 3
```
strip out all commas for a given nth column's entries (index starts at 0). So, for the input above, the program would output a .csv file like so for `n = 2`:
```
"apple","banana","applebanana","orange"
"grape","orange","grapeorange","sprout"
```
If the particular column's entries do not have commas, then it does nothing. Could have any allowable/manageable number of columns, and if you somehow find that creating a program that takes more than one argument, say, `a, b, c, ..., z` like this
```
program(a=1,b=4,c=65, ..., z=0, mycsv.csv)
```
for respective columns 2, 5, and 66, which all strip out commas for each, to be shorter, then do that.
---
Shortest code measured in bytes wins, and it doesn't have to be a file that is output/input.
[Answer]
## JavaScript (ES6), ~~95~~ ~~93~~ 90 bytes
Takes the content of the CSV file as its first parameter and the column index as its second parameter, with currying syntax.
```
let f =
s=>n=>s.split(/("[^"]*")/).map(c=>(c<' '?(k=0,c):k++-n*2?c:c.split`,`.join``),k=-1).join``
console.log(f(
`"apple","banana","apple,banana","orange"
"grape","orange","grape,orange","sprout"
`)(2));
```
[Answer]
# Ruby, 80 bytes
```
require'csv'
->n,x{CSV.read(x).map{|a|a[n].delete!',';a.to_csv(force_quotes:1)}}
```
A lambda that takes `n` and a file path argument, and returns a list of CSV rows.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 27 bytes
```
U|vy“","“©¡vyNXQi","-}})®ý,
```
**Explanation**
```
U # store index in X
|v # for each line
y“","“©¡ # split on ","
v } # for each in the split list
yNXQi","-} # if it's index equals X, remove any commas
) # wrap in list
®ý, # merge on "," and print
```
[Try it online!](http://05ab1e.tryitonline.net/#code=VXx2eeKAnCIsIuKAnMKpwqF2eU5YUWkiLCItfX0pwq7DvSw&input=MgoiYXBwbGUiLCJiYW5hbmEiLCJhcHBsZSxiYW5hbmEiLCJvcmFuZ2UiCiJncmFwZSIsIm9yYW5nZSIsImdyYXBlLG9yYW5nZSIsInNwcm91dCI)
[Answer]
# Python 2, ~~129~~ ~~126~~ ~~125~~ ~~98~~ ~~96~~ ~~94~~ 92 bytes
```
lambda n,f:''.join(c*((r[:i].count('"')-n*2)*','!=c)for r in open(f)for i,c in enumerate(r))
```
This is a lambda expression; to use it, prefix `lambda` with `s=`.
Iterates through each character of each line, filtering characters based on whether it's a comma and it's in a double-quoted string.
Now doesn't use the `csv` module at all!
Example run:
```
>>> s=lambda n,f:''.join(c*((r[:i].count('"')-n*2)*','!=c)for r in open(f)for i,c in enumerate(r))
>>> print s(2, 'test.csv')
"apple","banana","applebanana","orange"
"grape","orange","grapeorange","sprout"
```
[Answer]
# Sh + GNU Sed ~~GNU Sed~~, 36 ~~28 + 1~~ bytes
Run with `-r` flag.
```
sed -r 's/(,?"\w*),?(\w*")/\1\2/'$1
```
One argument to select proper column (1-indexed). This uses a GNU-specific sed extension.
---
Old version: `s/(,?\"\w*),?(\w*\")/\1\2/3`
This required replacing the last 3 to select the proper column (1-indexed), which I'm not sure is allowed.
[Answer]
# NodeJS, 129 bytes
```
(f,n)=>(require("fs").readFileSync(f)+"").split`
`.map(a=>a.match(/".*?"/g).map((b,i)=>i-n?b:b.replace(/,/g,"")).join`,`).join`
`
```
Defines an anonymous function that takes a file path and a number as input. It is no longer required to take input as a file, but I will leave this here for comparison.
[Answer]
## Vim, 32 keystrokes (excluding column index)
This uses 1-based column indices (which might make this answer invalid).
The problem here is that Vim does not start from the current character but rather from the following one... So it's not "easy" to match the 1st set of quotes. Instead, it finds the *closing* quotes and selects backwards.
### Solution
`qq` + the column index + `/\v"(,"|$)<cr>vF":s/\%V,//<cr><cr>@qq@q`
### Explanation
* `qq` starts recording macro `q`
* `/\v"(,"|$)<cr>` searches for the next ending quote or end if line. Preceded by the input column number, it finds the nth occurrence
* `vF"` visually selects the previous quote
* `":s/\%V,//<cr>` substitutes in the visual selection (`\%V`) every comma by nothing
* `<cr>` goes to the next line
* `@qq@q` makes the macro recursive, stops it and then play it until the end of the file.
### Gotchas
* If a column only contains commas, it will be detected as a column end and will break. This is a gray zone, I will adapt the answer is the question adds this to the test cases.
[Answer]
# Haskell, 56 bytes
```
n!x=Math.FFT.Base.adjust(filter(/=','))n.read$'[':x++"]"
```
Without `adjust` you'd have to do something crazy like this:
```
n#(a,b)|a==n|filter(/=',')b|1<2=b; .. (n#)=<<zip ..
```
[Answer]
# R, 59 bytes
```
function(f,n){x=read.csv(f,h=0);x[,n]=gsub(",","",x[,n]);x}
```
A simple function that takes `f`, the location of the csv file, and `n`, the column number to replace. Reads in the file, removes all commas from the `n`th column, returns the resulting data frame. R indexes from `1`, not from `0`.
[Answer]
# PHP, 81 bytes
```
while($r=fgetcsv(STDIN)){$r[$n=argv[1]]=strtr($r[$n],",","");fputcsv(STDOUT,$r);}
```
Run with `php -r '<code>' <n> < <csvsource> > <csvtarget>`.
] |
[Question]
[
**This question already has answers here**:
[Implement hyperexponentiation/tetration without the use of '^' [closed]](/questions/5562/implement-hyperexponentiation-tetration-without-the-use-of)
(47 answers)
Closed 8 years ago.
## The challenge
Implement the C equivalent of the `pow()` function (exponentiation) for natural numbers, in a language of your choosing, using only **addition**, **subtraction** (which includes negation and comparisons), **bit-shifting**, **boolean operations** on signed and/or unsigned **integers**, and of course looping.
(Note that this is different from [hyperexponentiation/tetration](https://codegolf.stackexchange.com/questions/5562/implement-hyperexponentiation-tetration-without-the-use-of), which is repeated exponentiation. This is merely a single application of exponentiation, which can be expressed mathematically as repeated multiplication.)
This is a code-golf challenge, so the shortest answer is king.
## Input assumptions
You are computing *x* raised to the *y* power. You may assume that *x* ≥ 1 and *y* ≥ 1, because 0 is not a natural number. (In other words, you don't have to check for 0⁰.)
## Output
Your function should return the correct value for all *valid* input, except in the event of internal overflow, in which case you may return a garbage value. (In other words, if your language only supports 64-bit integers, then you may return whatever you like for input such as x=10, y=100.)
## Bonus
There is a –10 point bonus if your function properly detects internal overflow and either aborts or returns some sort of error condition to the caller.
[Answer]
# Java, 84
A boring "addition in a double loop" method. One loop is to multiply, the other makes it happen more than once. Works until overflow on `int` types. The -10 bonus just isn't worth it in Java ;)
```
int p(int x,int y){int r=1,p,i=0,j;for(;i++<y;r=p)for(p=0,j=0;j++<x;)p+=r;return r;}
```
[Answer]
# CJam, 21 bytes
```
{1@@,f{;0@@,f{;+}~}~}
```
Only uses stack manipulation, loops and addition.
[Try it online.](http://cjam.aditsu.net/#code=42%2042%0A%7B1%40%40%2Cf%7B%3B0%40%40%2Cf%7B%3B%2B%7D~%7D~%7D%0A~)
[Answer]
# CJam, 22 bytes
Since the other CJam answer uses nested loops, I went with recursion. It's a lot slower.
```
{:X({:BX(F0\{B+}*}&}:F
```
[Try it online](http://cjam.aditsu.net/#code=7%205%0A%7B%3AX(%7B%3ABX(F0%5C%7BB%2B%7D*%7D%26%7D%3AF%0A~).
[Answer]
# [Element](https://github.com/PhiNotPi/Element/), 18 bytes
```
1__'['[2:'+"]#"]#`
```
This is just a simple double-loop solution. It only uses addition and simple stack operations. (I'm not done golfing yet).
Input is like
```
5
3
```
for `5^3` giving `125`.
Here's a very similar 18 byte solution:
```
1_'_'["#[2:'+"]']`
```
[Answer]
# Pyth, 27 bytes
```
K1Vr0@Q1J0Vr0@Q0=J+JK)=KJ)K
```
Works by adding numbers together whilst looping. Takes input in the form:
```
x,y
```
Try it [here](https://pyth.herokuapp.com/?code=K1Vr0%40Q1J0Vr0%40Q0%3DJ%2BJK%29%3DKJ%29K&input=3%2C3).
[Answer]
# Haskell, 37 bytes
```
(foldl1((sum.).replicate).).replicate
```
Usage example (note: exponent comes first, then base):
```
Prelude> ((foldl1((sum.).replicate).).replicate) 5 2
32
Prelude> ((foldl1((sum.).replicate).).replicate) 6 3
729
```
[Answer]
# Python 2, 67 62 bytes
```
m=lambda x,y:y and x+m(x,y-1);p=lambda x,y:y<1or m(x,p(x,y-1))
```
This is an obvious solution: define multiplication in terms of addition, then exponentiation in terms of multiplication.
Unfortunately, this rather naive implementation very quickly reaches the maximum recursion depth (Python's default maximum depth is `1000`, I think). For instance, you can do `p(9, 4)` and it immediately outputs `6561`. But if you try `p(10, 4)` it chokes, because it ultimately has to evaluate `m(10, 1000)` (that is, `10*1000`) and it takes `1000` nested additions to do it.
Of course, you can always raise the stack depth limit...
By the way, `p(0, 0)` returns `1`, which is desirable behavior in my view (if interested, please see my answer and comment here: <https://math.stackexchange.com/questions/20969/prove-0-1-from-first-principles/1094926#1094926>).
Thanks so much to xnor for saving me 5 bytes!
[Answer]
## Powershell - 124 bytes
```
:\>cat pow.ps1
filter m([double]$a,$b){$r=0;while($b--){$r+=$a};return $r}
filter p([double]$c,$d){$s=1;while($d--){$s=m $s $c};return $s}
:\>cat pow.ps1 | wc --chars
124
:\>runpow.bat
:\>powershell -nologo -noexit -c "& {. .\pow.ps1; p 3 4;p 2 10; p 10000 77; p 10000 78}"
81
1024
1.0000000000004E+308
Infinity <------- if result above [double]::MaxValue
```
# PowerShell 51 bytes
(answer prior to edit concats a multipliable string and evaluates it )
```
$p=[string]$args[0]+"*";powershell($p*$args[1]+"1")
```
result
```
PS E:\> .\pow.ps1 10076.45 77
1.79755288402548E+308
PS E:\> .\pow.ps1 2 10
1024
PS E:\> .\pow.ps1 10 100
1E+100
PS E:\> .\pow.ps1 4 20
1099511627776
PS E:\> .\pow.ps1 20 4
160000
PS E:\> .\pow.ps1 10077 77
Infinity
```
] |
[Question]
[
**This question already has answers here**:
[Reverse stdin and place on stdout](/questions/242/reverse-stdin-and-place-on-stdout)
(140 answers)
Closed 4 years ago.
Simple problem, create a programme that takes one input, and the outputs that input in reverse.
Some test cases are [input -> output]:
```
Hello World! -> !dlroW olleH
Code Golf -> floG edoC
Reverse Cat Programme -> emmarporG taC esreveR
```
Shortest answer wins
Note: It doesn’t have to support multi-line inputs and it doesn’t matter how input is taken
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~30~~, 29 bytes
```
s=>string.Concat(s.Reverse())
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9WmpdsU1xSlJmXrgOh7BTSFGz/F9vaQbh6zvl5yYklGsV6QallqUXFqRqamv@tucKLMktSfTLzUjXSNJQ8UnNy8hXC84tyUhSVNDWt/wMA "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
## [Keg](https://esolangs.org/wiki/Keg), ~~4~~ 1 byte
This is in the documentation:
```
^
```
The mechanism is simple: Reverse the whole stack. The stack is in fact a string, and input will trivially be the items in the stack.
There isn't an online implementation; download the Python interpreter and run this program, with the input prepending the `^`.
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), 80 bytes
```
[S S S N
_Push_0][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_top][S N
S _Duplicate_top][T N
T S _Read_STDIN_as_character][T T T _Retrieve_input][S S S T S T S N
_Push_10][T S S T _Subtract][N
T S S N
_If_0_Jump_to_Label_PRINT_LOOP][S S S T N
_Push_1][T S S S _Add][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT_LOOP][S S S T N
_Push_1][T S S T _Subtract][S N
S _Duplicate_top][T T T _Retrieve_input][T N
S S _Print_as_character][N
S N
S N
_Jump_to_Label_PRINT_LOOP]
```
Letters `S` (space), `T` (tab), and `N` (new-line) added as highlighting only.
`[..._some_action]` added as explanation only.
Since Whitespace inputs one character at a time, the input should contain a trailing newline so it knows when to stop reading characters and the input is done.
[Try it online](https://tio.run/##K8/ILEktLkhMTv3/X0FBgYsLiBXABCcXpwInJydQEEgrADlgEZAchAFSB1KOEOEE6QICqBlc//97pObk5CuE5xflpChyAQA) (with raw spaces, tabs, and new-lines only).
**Explanation in pseudo-code:**
```
Integer i = 0
Start LOOP:
Read STDIN as character, and store at heap-address i
Character c = character at heap-address i
If(c == '\n'):
Jump to PRINT_LOOP
i = i + 1
Go to next iteration of LOOP
function PRINT_LOOP:
i = i - 1
Character c = character at heap-address i
Print c as character to STDOUT
Go to next iteration of PRINT_LOOP
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 1 [byte](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function.
```
⌽
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HP3v9pj9omPOrte9Q31dP/UVfzofXGj9omAnnBQc5AMsTDM/h/mnpQallqUXGqgnNiiUJAUX56UWJubqo6AA "APL (Dyalog Unicode) – Try It Online")
Do I need to explain this?
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 1 byte
```
R
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/6P9/j9ScnHyF8PyinBRFAA "05AB1E – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 1 byte
```
Ô
```
`w` also works.
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=1A&input=IkhJIg)
[Answer]
# ZX81 BASIC (Timex TS-1000/1500, ZX80 with 8K ROM etc... assuming sting input only) 87 tokenized BASIC bytes
```
1 INPUT A$
2 LET B$=""
3 FOR I=LEN A$ TO 1 STEP -1
4 LET B$=B$+A$(I)
5 NEXT I
6 PRINT A$;"->";B$
```
Very simple, enter a string (stored in `A$`) which is then transferred one character at a time to `B$` from the last to first character in the `FOR/NEXT` loop between lines 3 through 5 inclusive.
Output is shown on line 6.
[Answer]
# [Haskell](https://www.haskell.org/), 7 bytes
I think it is self explanatory.
```
reverse
```
[Try it online!](https://tio.run/##y0gszk7NyfmfpmAb878otSy1qDj1f25iZp6CrUJBUWZeiYKKQpqCUgZQTb5CeX5RTorS/3/JaTmJ6cX/dSOcAwIA "Haskell – Try It Online")
[Answer]
## Pyret, 65 bytes
```
{(x):string-from-code-points(string-to-code-points(x).reverse())}
```
Unfortunately Pyret doesn’t have a built in string reverse function, so you have to convert it to a list, reverse it, and convert it back.
[Answer]
# Java 8, 14 bytes
```
s->s.reverse()
```
I/O is a `StringBuilder`.
[Try it online.](https://tio.run/##ZZCxTsMwEIb3PsXhyVbVPEBRGegACxWiAwPqcNjXysWxI98lFUJ99uAmYYhYLJ3/7@47@4wdrs7uq7cBmeEFffxZAPgolI9oCXa3EmAv2cfTY@uDowxWz2s294W6LsrBguIt7CDCBnpePXCVqaPMpE1/o5r2MxRg4rrkHdTFOk38OACaUSnEotUzhZDgPeXg7tSg@Uu2yRE8pXCcX7@NNtiiwGtOp4x1TerfgoN46BjF5clNK5N6/81CdZVaqZoSSoh6iJdqDWoZK6sjXeZ/MgLGTKJr/ws)
**35 bytes with `String` as I/O instead:**
```
s->new StringBuffer(s).reverse()+""
```
[Try it online.](https://tio.run/##ZY/BTsMwDIbvewqTU6JqfQAQHNhhXDZN7MABcTCpO2WkSRW7RQjt2UvWhgPiYtn@/fuzzzji@tx8TNYjM@zQhe8VgAtCqUVLsL@WAEdJLpzA6pKwucv9yyoHFhRnYQ8B7mHi9UOgzzL/OLQtJc2mTjRSYtKmUmq6Wvvh3WdXMY/RNdBleNn/@gZoFrIQi1ZP5H2El5h8c6Nm9q@yiQ3BNvr2b/t5AcIGBQ4pnhJ2Hal/V8/g2VEec6EfpKCPXyzU1XGQus@i@KBnuVK3oKpQ26U0Zetl@gE)
[Answer]
# [Dart](https://www.dartlang.org/), 34 bytes
```
f(s)=>s.split('').reversed.join();
```
[Try it online!](https://tio.run/##S0ksKvn/P02jWNPWrlivuCAns0RDXV1Tryi1LLWoODVFLys/M09D0/p/biKIruZSUCgoyswr0UjTUPdIzcnJ11Eozy/KSVFU19S0RpZ0zk9JVXDPz0lDlwiCmKzgnFiiEFCUn16UmJubClZU@x8A "Dart – Try It Online")
Pretty convoluted, you have to get a String List then reverse it and join it back for it to work.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 11 bytes
```
@(a)flip(a)
```
[Try it online!](https://tio.run/##y08uSSxL/Z@mYKugp6f330EjUTMtJ7MASP1PySwu0EjTUPJIzcnJVwjPL8pJUVTS1PwPAA "Octave – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
U
```
[Try it online!](https://tio.run/##y0rNyan8/z/0////HkBmvo5CeX5RTooiAA "Jelly – Try It Online")
`Ṛ` would also work here.
[Answer]
# [Python 3](https://docs.python.org/3/) (or 2), 16 bytes
```
lambda x:x[::-1]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCqiLaykrXMPZ/QVFmXolGmoaSR2pOTr6OQnl@UU6KopKm5n8A "Python 3 – Try It Online")
Lambda that reverses its input
] |
[Question]
[
Your job is to find the location (read index) of a given element `X` in an array gone through the following transformation process:
1. Take a fully sorted integer array of size `N` (`N` is known implicitly)
2. Take any random number of mutually exclusive even index pairs (as in that no index appears in more than 1 pair) from the array and swap the elements on those indexes.
A sample array can be like
```
[5, 2, 3, 4, -1, 6, 90, 80, 70, 100]
```
formed by
```
// Take fully sorted integer array
[-1, 2, 3, 4, 5, 6, 70, 80, 90, 100]
// Take some even index pairs : (0, 4) and (6, 8)
// Swap the elements in these indexes. i.e., element at 4<sup>th</sup> index goes to 0<sup>th</sup> etc.
// Final array:
[5, 2, 3, 4, -1, 6, 90, 80, 70, 100]
```
and a sample `X` to find in this array can be
```
-1
```
You should output the index of the element `X` in the final array (`4` in the above example) or `-1` if the element is not found in the array.
**Rules**
* In built searching functions are prohibited.
* You must write a method/function/program which takes input from STDIN/Command line arguments/Function arguments.
* Input must be in `<Array> <X>` format. Example: `[5, 2, 3, 4, 1, 6, 9, 8, 7, 10] 1`
* ~~The input array may also contain duplicate integers. In such case, any one index can be the output. **UPDATE** : You may assume that total number of duplicates << (far less than) size of array.~~ For the benefit of the question in general, duplicates are now prohibited to avoid playing a role in time complexity of the searching algorithm.
* Output should be the index of the element `X` in the array or `-1` if not present.
**Scoring**
* Being a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") and a [code-challenge](/questions/tagged/code-challenge "show questions tagged 'code-challenge'"), your score is calculated by `<byte count of your program>*<coeff. of complexity>`
* Coefficient of Complexity is decided based on the worst case time complexity of your code (Big-O) using the mappings given below.
* If your code needs to know the length of the array, it can calculate length using inbuilt methods and that won't be added to the time complexity of the searching part of the code.
```
Time Complexity Coefficient
--------------------------------
O(1) 0.25
O(log(n)) 0.5
O(n) 5
O(n*log(n)) 8.5
O(n^2) 10
O(greater than n^2) 20
```
Minimum score wins!
**Bonus**
* Multiply your final score by `0.5` if you can handle a case where the array has gone through the step 2 in the transformation process `I` times (instead of just 1), where `I` is passed as the third parameter in input.
* Note that while going through step 2, `I` times, pairs in each step are mutually exclusive, but pairs in different steps can have common indexes.
[Answer]
# JavaScript (E6) 97.5 (39\*5\*0.5)
(O(n), linear search, the array can be scrambled again and again)
The function accepts (and ignores) a third parameter
```
F=(a,x)=>a.map((e,i)=>e-x?0:j=i,j=-1)|j
```
or
```
F=(a,x)=>a.some((e,i)=>(j=i,e==x))?j:-1
```
or
```
F=(a,x)=>a.every((e,i)=>(j=i,e-x))?-1:j
```
**Test** in FireFox/FireBug console
```
F([5, 2, 3, 4, -1, 6, 90, 80, 70, 100],-1, 2)
```
*Output*
```
4
```
[Answer]
# Golfscript, 20 \* 2.5 = 50
```
~{={0:-1}*0):0}+%;-1
```
Explanation:
* `~` - eval the input. It should be in the form `[-1 0 3 2 4] 3`.
* `{...}+%` - prepend the last argument (needle) to `{...}`, then map the resulting function over the array
* `;-1` - discard the results of the mapping, and push `-1` to the stack.
The real fun is what happens inside:
* `=` - check if the needle matches the haystack element
* `{0:-1}` - take the current value of the variable `0` and store it into the variable `-1`.
* `*` - execute the function n times = execute if the previous is true.
* `0):0` - increment the current value of `0`.
yep. In golfscript, ~~numeric~~ all literals are just variables initialised to some useful values.
[Answer]
### Haskell, 51 \* 2.5 = 127.5
```
a 0= -1;a x=x;f[]_= -1;f(h:t)n|h==n=0|1>0=a$1+f t n
```
ungolfed:
```
adjust 0 = -1
adjust x = x
find [] _ = -1
find (x:xs) n | x == n = 0
| otherwise = adjust $ 1 + find xs n
```
[Answer]
# Python ~~79.75 (319\*0.5\*0.5)~~ 106.5 (213\*0.5)
**UPDATE**: Since the time complexity is determined by worst case for any number of swaps, I have reduced my algorithm to work only for the case `I=1`, which results in O(log n) time.
The findX function is f~~, while g, and h are helpers.~~
The function uses the ordering of the odd indices to apply search to find where X should be. If X has been swapped then it uses a second binary to search to find where X has been swapped to, based on the value found at where X should have been. Since I use two binary searches in the worst case it is O(logN).
~~I find X by applying a binary search on the odd indices. If X is not found on the odd indices, I check the array at the even index where X should be if the array was ordered (call this value n1). If n1 equals X, I found the index. If n1 does not equal X I use the same binary search to find where n1 should be in the ordered array (to see if X was swapped with n1). Call this new value n2. If n2 equals X, I found the index. Otherwise I use the same binary search to find where n1 should be in the ordered array (to see if X was swapped with n2) ... etc.~~
The algorithm terminates when X is found or n1 is found a second time.
Essentially my algorithm traces the random swapping in reverse. That is, it will 'decode' the last swap, then 'decode' the second last swap, and so on until I decode the first swap. For each 'decode', I use a binary search ( O(logN) time ), plus an additional binary search to find the first index. The algorithm will 'decode' the simplest sequence of random swaps to get to the given state (e.g. the algorithm will not apply any decoding to an array that had the same swapping applied twice). Also, note that any sequence of swapping will be equivalent to a sequence of swapping of length less than or equal to N/2. Hence the complexity is at worst O(min(I, N/2) \* logN) and the algorithm works for I swaps.
```
def f(l,X):
m=len(l)
i=g(l,X,0,m-m%2)
return -1 if i>=m else i if l[i]==X else g(l,l[i],0,m-m%2)
def g(l,X,n,m):
a=(n+m)//2
a+=a%2-1
return n if m<=n else g(l,X,a+1,m) if l[a]<X else g(l,X,n,a-1) if l[a]>X else a
```
~~def h(l,F,X,s,m):
i=g(l,F,0,m-m%2)
return -1 if i==s or i>=m else i if l[i]==X else h(l,l[i],X,s,m)~~
Ex:
`print f([-1, 2, 3, 4, 5, 6, 70, 80, 90, 100],-1)
print f([5, 2, 3, 4, -1, 6, 90, 80, 70, 100],-1)
print f([5, 2, 3, 4, -1, 6, 90, 80, 70, 100], 5)
print f([-1, 2, 70, 4, 90, 6, 3, 80, 5, 100],-1)`
Output:
`0
4
0
0`
[Answer]
# JavaScript ES6, 95 (38\*5\*0.5)
Performs an `O(n)` search. Accepts bonus parameter but ignores it
```
f=(a,x)=>a.reduce((p,c,i)=>c-x?p:i,-1)
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 8 years ago.
[Improve this question](/posts/8598/edit)
My last puzzle has generated some confusion and controversy so I decided to give up, for now, on those "replace one character"-type puzzles.
Hope this 4th puzzle will redeem myself after all the edits in puzzle 3 and will put your brains at work once more.
I've really put up all the effort to make this one as clear as possible and hope you will enjoy it!
So here it goes:
We start from a very short C program:
```
int main() {
int a = 93;
int b = 11;
int c = 22528;
// insert your code here
}
```
Your job will be to swap the values of the variables a,b,c like this: a <= b, b <= c, c <= a. To make it even more clear: new a = old b, new b = old c, new c = old a.
You are required to do this by inserting **one single instruction** in the line indicated by the comment in the code. To be clear once again, this line will contain only one semicolon (;) indicating the end of the lone instruction. After the execution of this program, a will contain 11, b will contain 22528, c will contain 93.
However, there are some conditions that need to be met. So we'll have 4 different puzzles with different cryteria.
**4.1.** Do it by using whatever you want. Just one statement. -> **most creative** solution wins this one.
**4.2.** Do it without using any comma (,). -> **most creative** wins
**4.3.** Do it without any comma and with no more than 4 letters (+any other characters). -> **shortest** code wins
**4.4.** Do it without any comma and with no more than 4 letters and no more than 4 digits (+any other characters). -> **shortest** code wins
To make sure you understood, here's some code that is **valid** under the condition required but does not solve the problem:
4.1:
```
I_hereby_call_my_beautiful_function(nice_argument), int q=w, who_the_hell_is(w)+1;
```
4.2:
```
one = single + assignment;
```
4.3:
```
int w=12345678;
```
4.4:
```
int w=1234;
```
P.S. In case you haven't already noticed, 4.4 is the tough one here (I hope :D).
[Answer]
For 4.4 (14 characters, 1 digit and 4 letters):
```
int main()
{
int a = 93;
int b = 11;
int c = 22528;
b<<=a=(c=a)/8;
}
```
VS2010 with /Wall didn't show any warnings, but I'm still a bit suspicious about using `a` twice in there (even though it's only modified once).
[Answer]
## 4.4 21 19 characters
**Edit:** Now meets all the criteria for 4.4.
```
c=(b<<=a>>=3)>>8|5;
```
[Answer]
Classic inplace exchange (20 chars without spaces, category 4.1, 4.2):
```
c ^= b ^= c ^= b ^= a ^= b ^= a;
```
Total exist 9 xor-chains that implement this 3-way exchange
```
c ^= b ^= c ^= b ^= a ^= b ^= a;
c ^= a ^= c ^= b ^= c ^= b ^= a;
c ^= b ^= a ^= b ^= a ^= c ^= a;
a ^= c ^= b ^= c ^= b ^= a ^= b;
a ^= b ^= a ^= c ^= a ^= c ^= b;
a ^= c ^= a ^= c ^= b ^= c ^= b;
b ^= c ^= b ^= a ^= b ^= a ^= c;
b ^= a ^= b ^= a ^= c ^= a ^= c;
b ^= a ^= c ^= a ^= c ^= b ^= c;
```
and to continue of Gareth idea (No commas, 3 letters, 4 digits)
```
c=(b<<=a>>=3)/242;
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/199693/edit).
Closed 3 years ago.
[Improve this question](/posts/199693/edit)
Here, **x** (supplied as input) and **n** (the result of your computation) are both positive integers. `n * x = n shifted`. Find n.
Here's an example of shifting:
```
123456789 -> 912345678
abcdefghi -> iabcdefgh (letters = any 0~9 digit)
123 -> 312
```
Shifting only happens *once* to the **right**. Shifting left, e.g.
```
123456789 -> 234567891
```
is *not* a valid shifting.
## Rules
* Preceding zeros count after shifting. If the number is `10` and is multiplied by `0.1` (`0.1` isn't a valid input), the result is `1`, which isn't equal to `01` (`10` after shifting).
* If your number only has one digit, the shifted result is your number:
```
1 -> 1
4 -> 4
9 -> 9
```
* Given enough time and resources, your program/function should work for any **x** input, but you only have to support **x** in the range `[1,9]` without timing out on Try It Online.
## Test cases
For more test cases, this is [OEIS A092697](https://oeis.org/A092697).
```
1 -> 1 (1 * 1 = 1 shifted.)
9 -> 10112359550561797752808988764044943820224719
(In this test case, x = 9 and n = 10112359550561797752808988764044943820224719.
n shifted = n * x = 91011235955056179775280898876404494382022471)
6 -> 1016949152542372881355932203389830508474576271186440677966
```
```
[Answer]
# [Python 2](https://docs.python.org/2/), 31 bytes
```
lambda x:10**1045044/(10*x-1)*x
```
[Try it online!](https://tio.run/##XY/BisIwGITveYqhICS1YiP1Ushpl30EL7qHaBMN1r8lxuX36WsXLYjHb4ZvYPp7OnW0GrzZDa297BsLrnWZ57qs1mVVLeUIvNAq56FxHoeTO5wlF6RqgejSLRKuKUpCDlYw5klqu9C/mE9QjyTEn21DY5ODwY9tr04I30UwAiFaOjqpC13@7/YxUEL21V36Wwp0BJtZgwwzsAAZL1kJBI9pcFQmZ/OMPqVXzcXbAfFSvjty2aAf "Python 2 – Try It Online")
Produces enormous million-digit numbers. Uses the formula from [the OEIS page](https://oeis.org/A092697), `x*(10^m-1)/(10*x-1)`. But, instead of using the smallest possible `m` for the given `x`, we hardcode `m=1045044`, which works for each `x` from `1` to `9`. (I'm assuming only these `x` need to be supported, because bigger ones are impossible.)
We need an `m` that's divisible by the order of `10` modulo `10*x-1`. So, to get one that works for all `x`, we take the least common multiple (LCM) of the orders, giving `m=1045044`.
```
x order
-----
1 1
2 18
3 28
4 6
5 42
6 58
7 22
8 13
9 44
```
We save a few bytes by doing `10^m/(10*x-1)` instead of `(10^m-1)/(10*x-1)`, since Python 2's floor division cuts off the remainder and gives the same result, as long we move the `*x` after the division.
Despite how the massive the results are, TIO can in fact compute them for every `x` from `1` to `9` without timing out. Validating the rotating property of an output string-wise takes longer, but if you set `validate=True` in the TIO link and the limit to a single `x`, this also completes before timing out. I've also validated all the results on my machine.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~54 48~~ 44 bytes
*Saved 4 bytes thanks to @xnor*
Takes input as a BigInt. Based on the formula given in [A092697](https://oeis.org/A092697).
```
f=(x,m=t=10n)=>~-m%(q=t*x-1n)?f(x,m*t):m/q*x
```
[Try it online!](https://tio.run/##bY3LDoIwFET3fsVdaNIWUVkKXk3cuTN@AYRXINBKuZgmBH@9tlvDbjLnZKbNPtmY6@ZNoVRFaW2FzOx7JIxOkuP1G/Y7NiAJE0aS3yoPBfG4Pw7C2EppZgAhkgkYuCCcfQgCDvMGIFdyVF156FTNUq9tZ7OkPPlHr3KcOoLYce0s98HXtKdWxZST1@5N/ZDENAcBa5OuWOwP "JavaScript (Node.js) – Try It Online")
---
# [JavaScript (Node.js)](https://nodejs.org), ~~165 153~~ 151 bytes
Takes input as a BigInt and performs a recursive search.
```
f=(x,n='',i=-1)=>+n[[d,...a]=[...x*BigInt(n)+''],s=a.join``+d,0]&&n==s?o=n:n.slice(0,i++)==s.slice(-i,-1)&i<60&&([...2**29+'4'].some(k=>f(x,k+n,i)))&&o
```
[Try it online!](https://tio.run/##bY9Na8MwDIbv@xU6DH/EjknLGPRDHey229g1BBISp7jN5GGnI1D62zMHeho9SXrfl0fSqfltYhvcz5iT7@w89ygmTci5dpivJB4UlWWnjTFNhWUqU/bujh80CpKK80pHbMzJO6pr1emiYowQ45tH2pKJg2utKLRTSib1PudOJzJz@9eCMbEw11m23ij@wisT/bcVZzz06YyzIu2klIz5ufdBTICwoh1MsEfYLE3iwvUJoPUU/WDN4I@iXmLP1@lWy91/68vGyzDCNvkhpdIS@Sj2GXx3accldn82SMjgETIJt/kP "JavaScript (Node.js) – Try It Online")
---
**NB:** Both solutions assume \$1\le x\le9\$.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 42 bytes
```
#(10^MultiplicativeOrder[10,a=10#-1]-1)/a&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277X1nD0CDOtzSnJLMgByhUklmW6l@UkloUbWigk2hraKCsaxira6ipn6j2P6AoM69EQd8hXd8hKDEvPdXB8v9/AA "Wolfram Language (Mathematica) – Try It Online")
**xnor's method n-shifted my bytes...**
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 24 bytes
```
#(10^1045044-1)/(10#-1)&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277X1nD0CDO0MDE1MDERNdQUx/IVQbSav8DijLzShQc0qNNYv//BwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
⁵×’⁵*“ÐṂ+’¤:×
```
**[Try it online!](https://tio.run/##y0rNyan8//9R49bD0x81zATSWo8a5hye8HBnkzaQf2iJ1eHp////twQA "Jelly – Try It Online")** (The 1045044 digits do not fit within TIO's output)
An implementation of xnor's LCM method.
`⁵×’⁵*58!$¤:×` works in theory for 12, but there's no chance of calculating results with \$58!\$ digits within 60s using Jelly.
```
⁵×’⁵*“ÐṂ+’¤:× - Link: integer, x
⁵ - 10 10
× - multiply 10x
’ - decrement 10x-1
¤ - nilad followed by link(s) as a nilad:
⁵ - 10 10
“ÐṂ+’ - 1045044 1045044
* - exponentiate 10^1045044
: - integer division 10^1045044//(10x-1)
× - multiply 10^1045044//(10x-1)*x
```
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 12 bytes
```
T*<•GIs•°s÷*
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/RMvmUcMid89iIHloQ/Hh7Vr//1sCAA "05AB1E (legacy) – Try It Online")
```
T* - Multiply input by 10
< - subtract 1
•GIs•° - 10**1045044
s÷ - Integer divide
* - Multiply by input again
```
Port of [xnor's answer](https://codegolf.stackexchange.com/a/199711/85908)
] |
[Question]
[
# Challenge
Given two non negative integers `a < b`, output all countries, from the below Top 100 Countries, where area is between `a` and `b`: `a<= area <= b`.
# Example
```
147500,180000 --> uruguay, suriname, tunisia, bangladesh
1200000,1300000 --> peru, chad, niger, angola, mali, south africa
1234567,1256789 --> angola, mali
```
# Top 100 Countries by Area ([2017](https://data.worldbank.org/indicator/ag.srf.totl.k2?year_high_desc=true)):
```
russia..........................17098250
canada...........................9984670
united states....................9831510
china............................9562911
brazil...........................8515770
australia........................7741220
india............................3287259
argentina........................2780400
kazakhstan.......................2724902
congo............................2686860
algeria..........................2381740
saudi arabia.....................2149690
mexico...........................1964380
indonesia........................1910931
sudan............................1879358
libya............................1759540
iran.............................1745150
mongolia.........................1564120
peru.............................1285220
chad.............................1284000
niger............................1267000
angola...........................1246700
mali.............................1240190
south africa.....................1219090
colombia.........................1141749
ethiopia.........................1104300
bolivia..........................1098580
mauritania.......................1030700
egypt............................1001450
tanzania..........................947300
nigeria...........................923770
venezuela.........................912050
namibia...........................824290
mozambique........................799380
pakistan..........................796100
turkey............................785350
chile.............................756096
zambia............................752610
myanmar...........................676590
afghanistan.......................652860
south sudan.......................644330
somalia...........................637660
central african republic..........622980
ukraine...........................603550
madagascar........................587295
botswana..........................581730
kenya.............................580370
france............................549087
yemen.............................527970
thailand..........................513120
spain.............................505940
turkmenistan......................488100
cameroon..........................475440
papua new guinea..................462840
sweden............................447420
uzbekistan........................447400
morocco...........................446550
iraq..............................435050
greenland.........................410450
paraguay..........................406752
zimbabwe..........................390760
norway............................385178
japan.............................377962
germany...........................357380
finland...........................338420
vietnam...........................330967
malaysia..........................330800
cote d'ivoire.....................322460
poland............................312680
oman..............................309500
italy.............................301340
philippines.......................300000
burkina faso......................274220
new zealand.......................267710
gabon.............................267670
ecuador...........................256370
guinea............................245860
united kingdom....................243610
uganda............................241550
ghana.............................238540
romania...........................238390
laos..............................236800
guyana............................214970
belarus...........................207600
kyrgyz............................199949
senegal...........................196710
syria.............................185180
cambodia..........................181040
uruguay...........................176220
suriname..........................163820
tunisia...........................163610
bangladesh........................147630
nepal.............................147180
tajikistan........................141376
greece............................131960
nicaragua.........................130370
north korea.......................120540
malawi............................118480
eritrea...........................117600
benin.............................114760
```
## Names as separate list
```
russia
canada
united states
china
brazil
australia
india
argentina
kazakhstan
congo
algeria
saudi arabia
mexico
indonesia
sudan
libya
iran
mongolia
peru
chad
niger
angola
mali
south africa
colombia
ethiopia
bolivia
mauritania
egypt
tanzania
nigeria
venezuela
namibia
mozambique
pakistan
turkey
chile
zambia
myanmar
afghanistan
south sudan
somalia
central african republic
ukraine
madagascar
botswana
kenya
france
yemen
thailand
spain
turkmenistan
cameroon
papua new guinea
sweden
uzbekistan
morocco
iraq
greenland
paraguay
zimbabwe
norway
japan
germany
finland
vietnam
malaysia
cote d'ivoire
poland
oman
italy
philippines
burkina faso
new zealand
gabon
ecuador
guinea
united kingdom
uganda
ghana
romania
laos
guyana
belarus
kyrgyz
senegal
syria
cambodia
uruguay
suriname
tunisia
bangladesh
nepal
tajikistan
greece
nicaragua
north korea
malawi
eritrea
benin
```
## Areas as separate lists
```
17098250
9984670
9831510
9562911
8515770
7741220
3287259
2780400
2724902
2686860
2381740
2149690
1964380
1910931
1879358
1759540
1745150
1564120
1285220
1284000
1267000
1246700
1240190
1219090
1141749
1104300
1098580
1030700
1001450
947300
923770
912050
824290
799380
796100
785350
756096
752610
676590
652860
644330
637660
622980
603550
587295
581730
580370
549087
527970
513120
505940
488100
475440
462840
447420
447400
446550
435050
410450
406752
390760
385178
377962
357380
338420
330967
330800
322460
312680
309500
301340
300000
274220
267710
267670
256370
245860
243610
241550
238540
238390
236800
214970
207600
199949
196710
185180
181040
176220
163820
163610
147630
147180
141376
131960
130370
120540
118480
117600
114760
```
## Rules
* The input and output can be given [in any convenient format](http://meta.codegolf.stackexchange.com/q/2447/42963).
* The output can be in any case.
* No need to handle invalid input values.
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* If possible, please include a link to an on-line testing environment so other people can try out your code!
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* The code is not allowed to import the list from file or internet.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
[Answer]
# [Node.js](https://nodejs.org), ~~1170~~ 1164 bytes
Takes input as `(a)(b)`.
```
a=>b=>eval(require('zlib').inflateSync(Buffer.from('eNpFU8uS6jYQ/RVWyUzdU7cwmNeC2d9vSKUybattC9uSkeQh5utzZCbJBij147yaz0qdddBgU1DBKIM8LJwPqdv0Pj85W0uQdha0QbVWJLnZ3sYkDk4nGVCJawcxGjuk2dloBXEO1smomMPM0QW1jJU3ubKE/KlOW472S2iXJyodJMwR7byIEwziI4IfxbG17fLT3Ioz/HI2qdn01rXGj+y3jhS1nsX4gFYqn0k9Nk+lEGdQzYG9smkkekydHew0cSTCJhkWZAhMfm2tfdKN+d1+eRt0NWLJSr6sJipBY93a1mrg0IKbTNkAHx5U97RjJdVDMb2sWlavXgM2yB2jD76uPeZnpd/exYcaJbpMs2wy528xdEqDp45E7iPTeXVPwphSJ3ZduigraII4BtKrWwSVT/GRrRrFSCuRqWHuA8cUtboUZNhIE5im2wSd5mqwNSIdGHIefmbgcTaEkiZb/oIdmcfIRU/Gx7aaDupKTBcy/1Yy+rV8nxV0yubGL+b7nJkqz4eO8YWNzzVPbZcpkSQvJK0PlR/sVy6kzvopo/jBr3AvVi/SORELXpr/dynZiMGkYSaD/M4Jmu0w2GrJJ5jFWGc882Zp1L8tE4gyG7thTBlAhhe5Os+jl6f03SpJQkvLeDl5QW6cYzYwsw3ytEN2wv13jhxJvCk6S+vBQybe5884DTZ94vNnY4ek4e3tL+j79ePN/LgWxx+8lKi/XHr7LE/qsS9LysXuXBK7RMG/Tt51rCNU0Y0ljgozehykRNkxUsehzuCsDc6HEv70mioV+8tr0Y6T1c2jblnGiQui9Si0xKVgV0OISXE5KQ4FzqeAgc/j1OK83eJ4aAnbotyNCBfiETt4lOj2JJIUyuabL3Ei7ZZIzlQoyvFEAI9jmWCLC4auRHsmeOVxMR53Uey8IfrUo9ippZ/UQVqBRPfZCbMtcd9TwZZSiqxh19SUT91F1TnsptDA1S9BI6XZOyusyoU/jgNHm0SPzL5GcSgCilTtcZzuinPn6ciFAEV9arErbjXzLR0OGv2E2He05+z0gEus+dqXHmdnov8/zD/0T+y37+8fV/mt+rgamOv2/R9Hndmv','base64'))+'')
```
[Try it online!](https://tio.run/##ZdTLsqpWEAbgeZ7Cme5i57C4CQxOqkQRQUTlqswWsIDFXa7Cy59YSQappCc96q8HXX9ncIRd2OKm/72qI/Qr/vkL/vwj@PkHGmGxadFrwC3arJcCB@uvH7iKC9gja67CjTTEMWp/xG1dbtbIaI6OMFjb7HknTdebnSVy@HAqDbSnI3G0zs4cwL7fi4OVo3vKDf3i7wNNwhnF8jNcwCuKIilxqIN0Vi@Crk23VzSCWyZwHhjuUQrBPXA9Ta98pnvmh5ytFHevwSl8K9mQ01FRSw/5SnVlXV5uF3D3qExzmCE4y@S5uHosT1s0fmhzHWmXyeSDWZWnBausGr8DheJj3WbUeiFPKv2KKkC1DyUjZiZLLarqHmxyfL4qkItGThSyEt2XpyJ2ZZ6jfI5OaAKhZe@1NPf8XXqJS7qPo7NBRBSBzB4Ynq5Z7bbTcCM9RQZSZZsA9RzYRr47vTlH5M1Mi9zDJaA7r4DjI7nQs0RnB3473JBfNRGJ3s8QakFz6ehp5mjhHcmvQ8NyMo9vNnq4t6lJLY3xowEnLVRVVurPrTdZrk0qZmu2R2s/mC/vNOyE0OmD2vGNVJU5XNKTFXHlazIsNVJOKorLIAltKOfYD8hajcowVk2HVN48hIehOdtSOJPUcyZaV6jeLpiHQNGJgK@0/LWw6Co8PWNZ3Fvgh01u3UftDG6FSXbuvM2XsW5qMpNaZje6mLSupqw/mpaM5srHFyV/WvBAXlitHMBEK62mcdnRU0JBoP2G0oVeZpNZ4fvUlopdmiLu2hFZsY0BYzXaPR91dCi4u7cNn8tz6iZm7mWDnkbqc8O3Nu7zrUWM0n0OECcI7MH2RXY0qieLchYxvU5kvIhuBqkn3vtNCMUZk49Ty@sy@eosUZ@7x/CQzrx5UUi756h2bzjgCYosqReUzrlp5G@nQ@ky7LtDuD3JIw9KXLuE0LfgubWpkM6ColLwfcCihcH77CYuuKrWQ@bOd/a4vNAuCcmMup4FBmks3FVB3c/GXoqxbPdscc1oTVOdeYCBzsiY9311Ke71PB7lnSpmpbfX9ywczFNXoqv7vpgc46BZUOPWqUXcND7p3N2XZN7iT@wufRiJ9uT7Fn69U0q0HFukjpRddU1/2FGWKKnbh3@dh26uHTJLjFMJrNuic0poJXtc2H3oLwOubtU2xMed7Iqwldsgeyy6Ca7KSMv0CQGOWEAiDx0RvR6nMqrqUSCXAwnsT654QohdsuyJNoHldaRJUzxVUTmuv9cB7NCWXX99Eev116@wrrq6QD@KOtnEm8@v4AD42lAC@NTX12q1IsnV0A7JAOfvVTe0uIIl@l71Q4U7DL9XAaySAkaoS3/7D0WDv4wNxYB/sA/VoHb4XoUpjL5XFU5Q@736AHXxkUpY4M@KeujTFYxbHML/iQzLbfmPSH@aIP4t/nv8158 "JavaScript (Node.js) – Try It Online")
### Inflated code
```
`benin,eritrea,malawi,(…),russia`.split`,`
filter((_, e) =>
(
d += 16 + parseInt(
`47eo,344,so,(…),8ndso`.split`,`[e],
30
)
) >= a & b >= d,
d = 0
)
```
The base (30) and the hardcoded offset (16) were chosen to optimize the compression of the delta values.
[Answer]
# Wolfram Language 68 bytes
I am uncertain whether this satisfies the requirements.
This uses a built-in function named `CountryData`. Wolfram Language knows the areas of all the countries in the world, so it's simply a matter of determining those countries in which the area falls within the given interval.
```
c=CountryData;Cases[c@"Countries",x_/;(a=c[x,"Area"][[1]])<=#2&&a>=#]&
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~1961 1579~~ 1353 bytes
```
lambda a,b:["india,argentina,kazakhstan,congo,algeria,saudi arabia,mexico,indonesia,sudan,libya,iran,mongolia,peru,chad,niger,angola,mali,south africa,colombia,ethiopia,bolivia,mauritania,egypt,tanzania,nigeria,venezuela,namibia,mozambique,pakistan,turkey,chile,zambia,myanmar,afghanistan,south sudan,somalia,central african republic,ukraine,madagascar,botswana,kenya,france,yemen,thailand,spain,turkmenistan,cameroon,papua new guinea,sweden,uzbekistan,morocco,iraq,greenland,paraguay,zimbabwe,norway,japan,germany,finland,vietnam,malaysia,cote d'ivoire,poland,oman,italy,philippines,burkina faso,new zealand,gabon,ecuador,guinea,united kingdom,uganda,ghana,romania,laos,guyana,belarus,kyrgyz,senegal,syria,cambodia,uruguay,suriname,tunisia,bangladesh,nepal,tajikistan,greece,nicaragua,north korea,malawi,eritrea,benin,russia,canada,united states,china,brazil,australia".split(",")[i]for i in range(100)if a<=int((11*'1'+83*'0'+'a55554ynmlfa64411xrrrqqqonnmlkjjhhhgggeddddccccbbaaaa9999988888777766666'+10*'5'+'4444333333332222226yuo2lglel123yapeiji5pk4goj3gasjo42t74iztocxlgfrbzug6xllkbspd93n933wpmgfvqqh976432lga7yvrii551tsljigh0qyixgdj7rpqh4okvoqmyxnz3oaqxsq0t9zep2r60pp5vtodxdmu487kopui7mr4d8t9tihlkjtpyd2xpv6asvoze8wk3tl0fqj371st5rcq0gm4fe4eskogkqm904k2waqy0waou602s0ar6efucwcoocs6qeogey8kjw8k8kc8eaegyq4yseo56ww0kquc4kec4oseyif6w')[i::100],36)<=b]
```
[Try it online!](https://tio.run/##PVTbcqs6DP0Vpi9p9/acIYGQpLP7Jfv0QYAwCsY2voSYn@@RaefoBV@k5aW1NNgURqOrr@Hj3y8Fc9tDAaJ9//tCuicQ4CTqQBrEBBtMow@gRWe0NAKURMcpHmJPBThoeTPjkzojuNho9Pk29lyhqE0gyPFyzsWKbyy6KLoReqGJkQTkc0YARcKbGMYCBkcd8HPKzBkcw0jG8qJlgEd@DaIjZpTvZLJB8Hrbtzskfx@ocYvIuBpm2hmajdukJaKwMNHeUIhuwsRkSKHYrzkvgZ6BaQ1yZMg975vWd0veZKbMjvVxoH7I6sKhja2iTsTJAWlkkj1I8B1jtSb4FbKYqFmPgfXoUCSckTmMQAp0L7zlsp0SH3@/28GMzhjNjG2EQuNayMjYLO@KPRfHrcWfXmbjTJctcLAI6RD1jmrZIBkhiY3mFtoVhTZu5f0dLFexWjPoJAb6Tn8QBlYsuwEp@9iZgEV/oIchx8qZPYsl0IINUElY1o6sZVJetMydR6YYwBuRyW4Ie76ElpvALkJvnPhpIWoK2BdcIXsziyg5E0QWHYTLL/DrCozn/JTPWnbTRS@m5GTahGeHJSjhU/ablWpNHtzo4t6u5wnhRpAFZTHz7PCcKejRj0zNcmGAO/1ol@ViQzQbuauVNWLDJ@NwH0xYSfBYhbxt2RwtmMiuDhPr/2@FsQLLwOOU6TrYSAmIPo8Jwcs/3ioKry/i5e0vfQ7GFVQQzw3zwtdjWb7RUMCfD9Lh9fV4/HU4Hn5fq1@H8vD7AGeOOulZDdDU9fH4dM4ty2I0H033@ziOUkrsOTqOtgWOW45rjgtHk@Pw@1j@OpwZseaofuK0R5OiOSmpUB1PVQKLdKeznWpp7hWP8d3Up3CpaQumeyo5uHaLsnkqNbXe9rdK36pqtbMcHssy3i5NXTEYXNLDEZ3Px@DVneRYLomesr9fnF3G2kwPs8zpqbfKwPL0SxluG9qTa0prz49g@mc/x/p6mYyNdJld3V/DLdDIPQeb@tPTPhrwD7PhdZ2qoMphuVeXow9n1y2lnOsBa/STkdMy38p6Oq2wpHIFE5vy5EtwDQ6xWztjOt8saCSm63Rfr9N16q4I/G9Z6uTRnJt1LacldvWEXW08Jhqa9cA@vr@zc5@iat7@fLSfX9Zl@4bX46nMIYpjtS/e3r7@Aw "Python 3 – Try It Online")
*-382 bytes thanks to Shaggy*
*-226 bytes by a new data storage method and some changes by Jonathan Allan*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~845~~ ~~726~~ 724 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Ÿ•LˆB1?+β»,¦ïp,fpîÃUK„»L`l¢~Rζ₃f(–α9OÌHíÜ$;’*ʸšöÏG∞zW¦pƒ;₃øÅ^êà©Q₁¤
cΘ¥₄₃₁¾«ål5ó eù&AŠ×Y‡p3ΓòÔ¬Š|üÛT∊DìaM1Gæ³RùVòí¢ʒʒP,vζšƶ«Ƶ¹”jWL¦¹†Ãн‘ƶËθ±…KãÐΓ¼¿λ΋½ª%=KHÛá$çöα=ÍTćÒ¹∞ïkѧqγHšÎGêĆ[‹Î½žMcǝEØιœ₆λÔ#ζ₆Σγ’Ƶä"‚žlóƒβÀÙlƵ=αн#$½/Y€Š:¹!
ÿFw91?ì3-ŸWuµ\ú‹µú1vPε»ã#º{ǝ¯¼¢vN=тLʒ”T³é¶ùÅγ¬ë‘/ОaÕÄ"Õ-Ý–°ǝ-β₆›*ŽBÂ₂₄q••17ò÷•вå.•1d|WÈ!ÝWàÁвZr¦h…ù„D&«r4¡8!’}`U²†ánB;ÂMÒ¤wt\pm≠¤Ëм h6oìIdšÁô1•#„af…a f:„di" d'i":`’ž¦0…¥0ƒŠ ƒ¼0‡¤0£‰0ˆ‚0Š™0²Ð0Û½0Ê›0Þ²0»´ ¸0Žè0°×0Ïï0ÿ0¨¤0ãì0¾ç0Êä0èå0àÜ0çÐ0ƒÞ ‹…0©0׈0ÎÝ0ÿ0¬æ0̹0Äë0ã0ÌÚ0ص0¬¬0¤•0¸Ž0Ó±0ÜÞ0¹ä0ƒÞ Ïï0ê¢0‡Þ ïŽ •€0·±0Ý£0Êž0¼¤0ˆÖ0àç0§á0•ì0ÿ0å£0⎠€¢ «á0§…0Ý©0ÊŒ0•°0ˆ¨ˆÑ0ßÚ0ÄÒ0¬ì0Šè0‰Í0²á0°‚0°ˆ0ÿ0¯¬0ß»0í¿0°¦0ÿ0€¢ ™Æ0ÿ0Ìè0«á0ƒŠ Šß0ÑÝ0Ó•0À‹0ìÞ0äß0Öæ0ÿ0ã¼0Ñè0ÍÆ0Õ·0ÿ0Úˆ0Éã0ÄÑ0ÿ0«š0ÚÊ0„¡ ¡è0à›0ÿ0ÿ’0¡sÏ
```
No smart golfs yet, but will see what I can do later on.
[Try it online](https://tio.run/##JVRrTxtHFP3Or3CBplUKyVgpSkOKaKOmIAFtimhQmqoKJSAl9QeiqkRNo2pZHEJdnnYIDmDj9YvXJn7Fxsaske5hjATSiP6F/SP0jmOt5Jn7POfcuys6Rn71jl1cyLJrxPvPZm55uz9Teaq2URqZibbxCbzD9I99rhGlav8DH8X/HlQl15we/9Q1Qip343vM9eItNlpvusabywhQWVooYbHHnY0@G6b0RD14k8NRxotfsIsY7fzgmlOUbBpVYUq5pp@d2lCjPaR8HSh4xlC59LWMYfWea1gT11QIebwiW8ae4xDrQ@5s4BvYIwPeHqSpMIjKXfa/pfhp8DR4p21SlaRVL9FevUgV14g8Hu6ntD7FMH3uuEa4XsK/qkw510j3IYElFaJDOlJVLLhGhRza/birrxfrsFqxhZLKdWF@6PglglxjNorMb1imrSeq0MssF3qwezxzn/OwQI6sDYyeRG4jrCoy5JozbKviVYsWa0YlVIHlqReRbHaNNVnzoVAPqjwMvPHVi10qd@60tJJz9Z5rMtFOqnzUhKNvn97wdsO@1i7Lw39Q8WccaIhFHHgn76giV0@00MFfJxHKMIX45Hdd/5n9p0EmPUQF7FAJFbxQBbKxx7yvYknWRrACfzNW2hHh6VH2JNKu8ozPNQ4uS@cWTNfkx/@EV4Ef73VWdp8P53mkrvC/zordpwwWPI95DDIka8/vXkGRR1c8NgYp8Uztj/50CfYYDv@kHOZYZDjHL7u5Bb3/kgkw1C0sqvWTCKaY6oB0uL8R/gq7k@MMOOPD1EnkeEqV8I7dKixr3LaFl29knGuNeMY7@fzwUbPn4SePmjsfsKayRmnBPkqJelDGPPUgHfLdoqSghGtkxRmzWxMy5vrjgvJYElgnRyDAnAWilBdUpfcemFQW0sG2oCxWBRaRETgStM11eE1sQTVscRb4uo2UQAwbgjdkibsi6uHBMAbBVXYEVs9mBBYQaRSwweY5qgj4sScwTQm@Yk0gTEX2EldOMkfB7w2jClFOYANRQRXu1Cj9AcouxTUrfc9Ix6MHZHLqvo6P6JoBWRO8Bknmi9ca3pZgqS2hx2ZrJEjpsLhONm2Ke3hoFoc0YEc07IAM6mjKNqI3NUY/gpqBzfKxMqwm5rWGnJfVolJWM2WSGaaBTaoKfhH5muWRsPlDH9YdjSimzerqro1BcclNgWUtU0gLAINFFLCZPJLa9RqNKkjwQDluW2BeF1qh/YZ5Tff@BwmNcrmBYk9abEZA6I@V5SFL58Qac@b4I14WQdbvWLy48H5@vUOIJu8Xgn//Aw) or [verify all test cases](https://tio.run/##PVRrTxtHFP2eX7EYmlapacYBwksIFaWBCmjTiBSlhAoagkJLE5K0RGnTalkclzjhZYdAABuvXzzsxMaOjY2xke7JGgmkFf0L@0foHUfqarWauXPvmXPOndn7j4Z/GrtzNvmk3aZYLo9ia38ydGbkLDXYc@LqcLR/bqaoYKcoEhP20Qm8w/SNbkv1U6FnaJyCf183s5Y2PfqZpXrN3eZv8bILb7Fe02qpby7ATTlDRxbzndaM/49@ik6UPa2cjhye/YgdBGj7O0ubovC52@YKRSzNyYsyUKIYIuMNSCt3kD//pRHA8k1L1SfqTC9SeEVxI/AUB1jrs2bcVxAf7nV0Ikrp68h/z@tvKXjsOfZcs0@aWUMvZylWzlDeUn0/9/dQVI4CmD4tWupKOYsXZo52LTXajRAWTC8d0KFZwJyl5qlIO5@0dXdhDXoNNpE1d9sw2/fhH3gYY8aPxC9YpM0HZrqLVc51YueDa4DrMEdFo9R7@8j3FVbMvOG1NBfHCnhVLc1ymSEzzfaUMwjbLHXVKI0jXfaYKah4M17OtJm7p8XqGipevGlpLLSF8lXncHj1cbOjHfG6WiPX/ztlbmFfUsxg3zF5zcwweqia9v888lGCJQQnv2n7V@s59rDoPkpjm7LI45mZpjhirPsiFozSMJbgtGGpFj7uHiWPfLVmivlZ6v4Fo9gBzdL4dT7go8Cvo5Gd3ePBaQqRL2Rg5Gk/Zqrg60cAU6epHx5S9C4bCfbXf@U8xR7Wk95UxUr/GrpBKWm6fq@jFVov@xd@/NutiV@t5wEK48XpgXL38n3Evx5hH6fw3sHo1QwyPMpww8poC49HxmzKyKdjtpYhBjRKFBW8RhFR9hgBpeyhA57rFBYUstSkOGERq8IIWM6goBQWBNaoKOBmaQJ@Sgkq0HsFGuWEUcSWoCSWBeaREDgUtMU4fBrigkrY5CrwdAsRwTrXBR@EBd4VfoX9Zw6CUbYFlk9cAnPwVQDi4PBLygs4EROYphBPsSqwQhleJUYOs0bB14NZeWlXYB1@QXneqQL9kcoOBaUqOU8YRUX2QePSPZnvk5huoyS422HWi9eS3qagTehcFGT2zAQRmRaUxVqcggpfK51TKrR9krbb8MhskpbRFsMsCmxIpk54pI44m8j@sKeYlU5ydVJaS0mpl6UmWAw2qCD41vE0yY3h8Mfd2H1Uslg8eyz3rrSLITcEFqVZXmkDVLZSIM4WICyXXqOCghC3lfO2BGYl0BLtVcKrcu/nCEmWixUWMUPnMNxC/pl0hXRZE6h0m/MP@cgI0h9h/sx@NjDgqG9sEMLuaBL8DNoHHJfkgAN14v9IXX3D5Ua74xJ/m5oHB/8D).
**Explanation:**
```
Ÿ # Get the inclusive range of the two (implicit) inputs
•...• # Compressed integer 1973189551155729951158047504888550693285038979215196451111846739112857422275219605859797606876792240255951887197422137126381236888252746087204379433177795015673735312875287174369802127043070332938030374559331221793543099653787758410730754595832945510288634919093697357543931716347226050469833259385438225825153429642271254788538576531893907231375001829235576168553954340620130825485946678723358989342130504637082203898949974502648169087327686854812063938661992036699706767699157860904798957505081143747312911246515350313735031397786562111474800728183906801552964415604114267221708014650503416371603814718203653991102167755222616117998692632503630077961754668397032445720874683416593177351139861390338743408903539745973060232
•17ò÷• # Compressed integer 17098251
в # Convert the large integer to Base-17098251 as list
å # Check for each if its in the ranged-list (1 if truthy; 0 if falsey)
.•...• # Compressed string "benin eritrea tajikistan suriname kyrgyz gabon burkinafaso cotedivoire turkmenistan mauritania libya"
# # Split by spaces
„af…a f: # Replace "af" with "a f" (for "burkina faso")
„di" d'i": # Replace "di" with " d'i'" (for "cote d'ivoire")
` # Push all strings as separated items to the stack
’...’ # Push dictionary string "russia0canada0united states0china0brazil0australia0india0argentina0kazakhstan0congo0algeria0saudi arabia0mexico0indonesia0sudan0ÿ0iran0mongolia0peru0chad0niger0angola0mali0south africa0colombia0ethiopia0bolivia0ÿ0egypt0tanzania0nigeria0venezuela0namibia0mozambique0pakistan0turkey0chile0zambia0myanmar0afghanistan0south sudan0somalia0central african republic0ukraine0madagascar0botswana0kenya0france0yemen0thailand0spain0ÿ0cameroon0papua new guinea0sweden0uzbekistan0morocco0iraq0greenland0paraguay0zimbabwe0norway0japan0germany0finland0vietnam0malaysia0ÿ0poland0oman0italy0philippines0ÿ0new zealand0ÿ0ecuador0guinea0united kingdom0uganda0ghana0romania0laos0guyana0belarus0ÿ0senegal0syria0cambodia0uruguay0ÿ0tunisia0bangladesh0nepal0ÿ0greece0nicaragua0north korea0malawi0ÿ0ÿ",
# where the `ÿ` are filled with the strings on the stack to form: "russia0canada0united states0china0brazil0australia0india0argentina0kazakhstan0congo0algeria0saudi arabia0mexico0indonesia0sudan0libya0iran0mongolia0peru0chad0niger0angola0mali0south africa0colombia0ethiopia0bolivia0mauritania0egypt0tanzania0nigeria0venezuela0namibia0mozambique0pakistan0turkey0chile0zambia0myanmar0afghanistan0south sudan0somalia0central african republic0ukraine0madagascar0botswana0kenya0france0yemen0thailand0spain0turkmenistan0cameroon0papua new guinea0sweden0uzbekistan0morocco0iraq0greenland0paraguay0zimbabwe0norway0japan0germany0finland0vietnam0malaysia0cote d'ivoire0poland0oman0italy0philippines0burkina faso0new zealand0gabon0ecuador0guinea0united kingdom0uganda0ghana0romania0laos0guyana0belarus0kyrgyz0senegal0syria0cambodia0uruguay0suriname0tunisia0bangladesh0nepal0tajikistan0greece0nicaragua0north korea0malawi0eritrea0benin"
0¡ # Split this by "0"
s # Swap to take the list of 0s and 1s again
Ï # Only leave the strings which are truthy at the same index
# (and output the result implicitly)
```
[See this 05AB1E tip of mine (sections *How to use the dictionary?*, *How to compress strings not part of the dictionary?*, *How to compress large integers?*, and *How to compress integer lists?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand how the compression parts work.
[Answer]
# 1. Python 3.5, 1651 1458 1398 bytes
Script takes two arguments.
Lists are compressed using LZMA BZ2 zlib, encoded to Ascii85 and stored as two comment lines after fileheader. Script reads itself, decode and uncompress these lines.
```
#!/usr/bin/python3
#GhO`I6%\,>%(lBO\a@"&E!__Y)$A-Ff<:j\Zp8G1Q=R\[aL$##cd[#Pij[XO8YuBARE6=2nKRD/).0>%g#JDN88bcljG2%`4dgK<6&DcfL6B^8a,Q'!/kQ'%Y-V9;b`T;[FBm3&5T5Ys2U;CmXCF5:aq71_o,S+(:/uX&2L\fa_-/Kd'3s6'[G]sCn=J+=>6L_s/WA*`k@\':,lZ\ajllj%bUG0!qCp9F]27HBY(^&g;oVer&mCo)2`N/hX]II^\`uAc4tBW-9;`g,5d;uq]U>#PY..CpNFN`coGkC/^iJ/obu7<Xd,P9mG+g'N^u=3rEV<?>g(ktsJ*-0h`)JN0Qd/g$HOCkHOS9NOk5I@9mZQ(AT,&:D;D=6G:^[[=SHh;43Hhl.<kEAOiIW\\PrK;#`D?:k8qUU%%3@#\g19gTi`i0D3F,XH+;50n"r1ef9*)"a%bqYamDW(>P'r!bI:.gVAFJm8ke"\jNT^XS'D6lJVC=QibmBbdYu]A8q<$V4oh+DO0HR653:K@ZfLgC/3eQ1hYB;?.Jjffo6Hki<jQp>/o`2CO`l:75X50!JL1D.3e=%;ln5E%^0_p`^=LEEs0IQl*(,e5p
#GhOI,<t5?f#XeVP%DCQs@Uj%oUjWTD(l41.HE#\:p4+)_#$1Vhad1Jm5*P-3'#*CKij5)RT]`;4pYs(Neg<]+lVk(SN$V1O9Pimd<c%%.IW.a[YSm[1ht!C1:I<SVjZTUuYN)7^7#D((KD4T-=AM;V^T&UWbMi,>Ya\!/(t[6!A*tabY2Lt='tB`J]`oHWl03e4Qa=fZMu[=U-hfuQCD>b8o=4o2"T](^/'MZsb3+#T@&p,HQpC)FCec9Pc,M&NdXUa=S#I(4#dd3;6_)*Z5X]!WZ\%VJ@B<m-&^)`PH9K1r2i(<4Qn2P8MFP!EJj1eD\H@e>m"$h-X4`AC]fg"I/tPODfK,?*5Ru-l`$`>#lJhuVj.;nHE<`u/&mBdGT\n$Vp'4N#:<19D9Z+4@P<2aQG[ohN)/bpcZ+ghPo`GO.K*_
from base64 import*;from zlib import decompress;from sys import*;(f,t)=[*map(int,argv[1:3])];g=open(argv[0],"r");l=g.readlines();g.close()
def d(l,n):return decompress(a85decode(l[n][1:-1])).decode().split("\n")
n=d(l,1);a=d(l,2);o=[]
for i,b in enumerate(a):
if f<=int(b)<=t:o.append(n[i])
print("{},{}\t->\t{}".format(f,t,", ".join(o)))
```
I know, it's not pretty to abuse comments like this. But it works... for golfing.
To include binary data in text file you need to encode it to printable chars only. But base64 encoding is not dense enough, that is why I used A85. But it has chars that need to be escaped in order to put this in python string.. So then I use comments :)
## Explanation
```
# imports
from base64 import*
from zlib import decompress
from sys import*
# parse input as integers
(f,t)=[*map(int,argv[1:3])]
# open this file and read all lines
g=open(argv[0],"r");l=g.readlines();g.close()
# from array of lines get line n; strip leading "#" and trailing "\n"; decode from Ascii85; decompress; decode from bytes to string; split on newline
def d(l,n):return decompress(a85decode(l[n][1:-1])).decode().split("\n")
# decode list of names, list of areas and create empty output list
n=d(l,1);a=d(l,2);o=[]
# cycle through list of areas
for i,b in enumerate(a):
# if curent area is between limits, append country to output list
if f<=int(b)<=t:o.append(n[i])
# print formatted output
print("{},{}\t->\t{}".format(f,t,", ".join(o)))
```
edit: changed compression method and removed map(int) before enumerate
<https://docs.python.org/3/library/zlib.html>
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 736 bytes
```
“þṾṚSẸL£ỵƘhŀẠṗµA+QØḣœḢpṗżÐEn⁷ȦyẈ⁷g%v3ọṇ(Ƥd>OṾTṭAJẓṛṢƊƭḟ¢ẊȦ9c°ÐṄ5IqżQo⁾Ṣæṗʂ"OƥkpṙY!e}Q/ẆⱮṠyṄ0ØȥLYỊṃ~+æ+İbɠṇxƊƁjjtẓ?ạ5ỌżṆiⱮẆj/ȯ¬ẉ⁹Œ¿żÐX¥hẇyqJ~⁶Żḟ#1QJṗ¹n³H.ḋ(Ṣ^ỊẆKḲŒU[⁵6¢2ȯdG/⁼ṭḥİ!ƈ3ḤḳUıHṇlṄ⁽€ẆṠwẈƁḣḳµ!⁾³Ḋ¦Ṭḳ0ƈØʠ⁴æ?+Ịṙ4⁸8Żḅ| GḅɗṆĠKİb"ḃɲʠµY⁴ḟnỊẋ⁺V³ṚĖıknṠƊMeẓƬḌ⁺£©9⁴ȥøẓɦ&7ɱ_2ɠȷṂẋṚcṇṫḢ)MȮ¶I7ıṃ1LŻỌƊḞYrỴȦṠṣ3ḥ<Ƥ½’ḃ“¡æ⁽ż’e€³rƝḢ¤Tị“Ṇ¹zẏƥKDTịAjṇẒ¤<Ṁ6:-jOʂƑṆɠw@Ẉṙ]Ż§!œ~Cıu",©ḳṂƒḥ¢Ė~,ḲsĿỊƭṀjⱮḳ%o!Ðrḍ3©ƊZØq-JṪƤƘÑẹ04ⱮṂṛ'÷ƥÆƁ¦z¢Ẓ3kaṁ⁾ẏHnĊ^ḍỤfçÄŒṅṣḍƒb ybḤċÄæ¬).sḋ ėmẸeHẈŀ⁺U®`nɓƙt ZeNH+¥ḋỌLYÑ¥ḳƬȤƘ³ẓ½⁸¢ṛŻḍ\ƙß³ÞdȦḲµṫk¡ẓ⁶ẒṠƑ~ġ+=3þḌ÷z⁾ñ9cø.'3ṆN⁸0HḟN+ƒN⁼ƁKạṪƲ⁽żė@ÑṣT³ṠQƁ1ṭ©>]Ɱr&Ị}°rð0ċ4ntėṭiḣƤ^/æmẠ8ZṪ®$ÄOẏ¬⁻v!ƭh]ḟÄF^Ẇß2Ɗ8þṄÆ⁴)ƒṛ⁺ƭ©ẹẓÑ3⁵|F}ß8"ÞḂṣ⁷%ƙ9Ɱ:D¥ĖĠÆ7ƒṭṘ³ɓċ³ɱTƊDɼ>Ɗ;ẹẇЃµcKṁ⁺ḳRỤ®+®lUṛ½ẒʂƊḃNʋḥæṠḤmḲ³ɓÑ`Ɲṗ[]ṠȮẏ3lḍƤʂXṃ4#ʠ°µḄƈẈıḥıẉ®×ḊẈƝỤġOlṠÆU½ẏ½ċƒµKRW»Ỵ¤K
```
[Try it online!](https://tio.run/##HVQPUxpHHP0qYmoSB6MgJmqaJnFqEyJGx1TbaKpN/dMaNKQam1QnOhwStKCjwEyA2CgikLFVAiLx9sBmZvduB/gWe1/EvoNhbo5l9/fe7733W@fU7OzixYXu/pv9Jwi@778XitxLD0SxwKPTmlsocUEitNBlHmBRIR9oYSEnfseSVmLb37l06aycXhTKOl5@a3hlE8VNQdau8uTk7X7UGxTkuKtHKGFBdgRJcD8/FvIeTQjFX053TtAs2xbEe/3BnFYaeKFLwE@wNIpXPfX9PDUDnNiwaWp5oEUoPj2XESS@iP0WFi2neodF0S/I6oqZpc1qdrwCnmt/AkFyOheAeEco@9dFcUMrCeJ7ZhxWfM6W8id6JJS/dIloIfrF6OExTU0LZW1xrmdFlz5rRfC7ZB3oMZomLpq3Nws5cBW8xgw4xecQ8okWGnqiS4UbNNFa/jR5v0WXgIHGUmrWxNdtQk4KOT@k5uxgNAu@unSuewDrA//X0IpLEBJbaMGEnmleyH6Kro@wZOHrLFqN69IpS98x1zqMtemS3GEQe/um7j6elQg6UuMONF0v5NXKSTVOC8M4AuquGsuALik/oC55r75TczMu4HL/wymowgGygX/pAT3sxJFyislYrqQvt1dyP7dW4uUzQTyogLMToC/Iv/C78WE5Qz8/aFdzENzaCy7FDe4X8u7wvCielsEd4h@g8dQtnqTnujsGXsgU3WdpNK@VsDIFCWh@nn9APZocFMUANqARSpaEssVTjm5jrctpgCohmrwliPvGzWvO/qqHB7GvEn99F9pBj1GtSD@atPDKt2ruj/omegjdQJqHgE8T6ruVJnj0Uv0CKRA34nYa5sv5hhcmtj0v5E0bPeT@ERaduwaX/@FJHmVBoRBLWy1hHkT1CjvjKebjEk0vGWEN2WZ@EUQyAqps2V2qfwxlRDH5K/vIvFpIkLdoH0s8NF63OA7/1QDzsjQ9amx@ifjUqZHnmKopO/hrbqg/RDNPXZUwjy3UjUz12c00hV3QtHeYBY33PD8qgxYcVMKQU5JBguwYEdj8icfYHs2z3UnILp/QAhyaofvYiPSCqWF1cEXdN39jw0TLG@xsCbRZrnOCyc1XbBCyD/UsdmSlz8xD@FHikgOzYkhxUjNLjdyFIORg0EhQfIBLVqSbHt4ehT7zl6HqMs3Os6xFDbS5FlSE8fgZ8syTYy0sjT7jHSOoRTNfMW8/5KJHulR8ZeLH06PAZN57YxgEttfK/R3GleNlPsSwEeaRHSjDAQQv0A4L2jBjb@4ts72OerYrZBhzgFumgcc6QeRmN00h3HHmazfOwmfIVQmrATxzg9zfXSnd5v6va7XW2DYP0cKEo@ahAn0fwTyaMdPM7BBw6TmEQ8yQ6NW@agAxYrVIy8nnhsQoy4JPEVwSeTKK9TKuki3brOF3sup5jJFou4QRzMIL2cvXYTLmBJdBDhcNzbAIxtsY@g/AVPf7cSGA9JCBuUXP1YDBzPHoR4qZOqVJx8XFhbWt3WqxNFk7LPj8Dw "Jelly – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 1656 bytes
```
function(a,b)d$s[d$c>=a&d$c<=b];d=data.frame(strsplit("russia,canada,united states,china,brazil,australia,india,argentina,kazakhstan,congo,algeria,saudi arabia,mexico,indonesia,sudan,libya,iran,mongolia,peru,chad,niger,angola,mali,south africa,colombia,ethiopia,bolivia,mauritania,egypt,tanzania,nigeria,venezuela,namibia,mozambique,pakistan,turkey,chile,zambia,myanmar,afghanistan,south sudan,somalia,central african republic,ukraine,madagascar,botswana,kenya,france,yemen,thailand,spain,turkmenistan,cameroon,papua new guinea,sweden,uzbekistan,morocco,iraq,greenland,paraguay,zimbabwe,norway,japan,germany,finland,vietnam,malaysia,cote d'ivoire,poland,oman,italy,philippines,burkina faso,new zealand,gabon,ecuador,guinea,united kingdom,uganda,ghana,romania,laos,guyana,belarus,kyrgyz,senegal,syria,cambodia,uruguay,suriname,tunisia,bangladesh,nepal,tajikistan,greece,nicaragua,north korea,malawi,eritrea,benin",',')[[1]],c(17098250,9984670,9831510,9562911,8515770,7741220,3287259,2780400,2724902,2686860,2381740,2149690,1964380,1910931,1879358,1759540,1745150,1564120,1285220,1284000,1267000,1246700,1240190,1219090,1141749,1104300,1098580,1030700,1001450,947300,923770,912050,824290,799380,796100,785350,756096,752610,676590,652860,644330,637660,622980,603550,587295,581730,580370,549087,527970,513120,505940,488100,475440,462840,447420,447400,446550,435050,410450,406752,390760,385178,377962,357380,338420,330967,330800,322460,312680,309500,301340,300000,274220,267710,267670,256370,245860,243610,241550,238540,238390,236800,214970,207600,199949,196710,185180,181040,176220,163820,163610,147630,147180,141376,131960,130370,120540,118480,117600,114760))
```
[Try it online!](https://tio.run/##LVLtbtw2EHyVQ1A0NsAWpMQPEU36IkF@rCSejjmJVCjJru7l3VmebeBGJPdjdmbLx/Xy7a@P65GGPeb0QqJ/Hf/Yfox/DP9@pz8B3773P/8Zv4@009/XQkt42fayrXPcX76UY9siiYESjSSOFPcwXrad9rCJ4RYTqhV6xFnQgSSaERvTiF8qU0g7B9zpQfcbcpIYcpqyoHkKBSEbHWO8UKEehyX8F4fMyTkFbrkdIzLm2J8oWfC5cDI3WEM50JxGkSIqCeJ7VEB3seVjv13oWuIA1nnOCxcP@y3mFR89CrxxNzpKBCN@m851F/h@1GMtCXwLKTyOgLqJllgZ5geh2u8jiJXusQ60H@UeTlZiDqI@I@6ktBBoXacbSta4J63nSFteqk4D9IFin2TTpYT16Oc4iONeKKYAkiNNtA2o1ed9eycWMyToAZfSEMQZlgAON4ozpVFsK9IqJVw/@w5ws@ScwHg96JLC@2U6UBvyvocRycejD5@zLLnkgS0o9FtMJYRUq64waDroFI@49NS/B5Fyecf5F63IgloLpVNc4zP8LYYdirEbdNbVyXu4jF/jW44FyuUaBQmSgAHzKVZoF9cVpDbRgztW5nKlLQsm@whU4yfqMUQYDhpzEZ8jfG4jMqYxL@KYEEmCRSdRuAO6z5Q3xJ9818NN7LO4n2U6H2KDwxPNYjtL3fClz7y4RznquBs2BIMECAoxeXewZzONYbuB2orEnX7FT@1YLhiSYGRVizWC4fdcQl1Meo8Ca7XzsYc56Yv4Kr6@/vihfv4Uw4ty0neNkcL7TlsH7FplFNDYxislOqOMw71zWjWNFG3TucZ40bhOaimBjfayEY3t8I9z2ymngUp766VQ3uq2Y1TSt0qozvnWdEI54w3iEIwOQGPRANh0pnkiyjOCVUWmV1Eqrtvgl1FplPBAqVt@xzyG@8lW1ngpleb5tONn37Q8jUcrXHaNblDDec8UnbeIFq4zLd6csdJbQINbYZ01iLSm4SGt1m0LaJ3lU9N4pFvZGuQZ6OMNQKEhQLboZ6BR54RpnOeTanlUI42HArrruK12RvPJ8uBCa6ebJ/CbtlxagxcDRmWQFuRE66UDiRZGuU5gOm9xaRxP1LYdVwFXbx1DJ9lBSAmAshwiveFLqVrNwH8wVbMHkN6pCrwZjbE8SqNN9Vm3rEujFTOD62wmAHQAlhvxCnAC8@MF8J59AhPkKdBllzB6XQJbPbdt9wQurbSzbYUaqRXUFlDOo7tqq6zsIqerTnOIejbiRPn6@vHxPw "R – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Random Capitalization](/questions/149491/random-capitalization)
(69 answers)
Closed 4 years ago.
SOMe PEOPle lIkE tO TYpE iN A LoGiCAL MAnNER, WITh CapITals aT tHe bEGiNnIng Of ThE SENtENCE and smaLl LETTErS EVeRYWHErE eLsE. NOT Us. NOt Us. Your joB iS to tAkE A SenTEncE Of A
LL SMAlL LeTTeRS, And rANDOmly ChAnGe sOMe to caPiTAl. ThiS iS a Code gOLF so tHE SmaLleST coDE WIll win.
the input will always be small letters and spaces with punctuation only.
random meaning running the code multiple times will always yield different results.
test cases for this will be hard since it involves random elements.
here is a shitty example with python
<https://onlinegdb.com/Hy0_gEEKH>
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 6 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function. Assumes `⎕IO←0` (0-based indexing)
```
⊢×∘?2¨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qG@qp/@jtgmG/x91LTo8/VHHDHujQyv@pwGFHvX2QWS7mg@tN37UNhHICw5yBpIhHp7B/9MU1EsyUhUy8wpKSxTKM3NyFBJzyhMrixWSUhWKcxOB/JzUkpLUomKF/LycSj11AA "APL (Dyalog Extended) – Try It Online")
`2¨` number two for each character
`?` random index among the first that many indices (i.e. 0 or 1 for each character)
`∘` then
`×` use that to change case (0:lower; 1:upper) on the following:
`⊢` the unmodified argument
[Answer]
# [Python 3](https://docs.python.org/3/), 59 bytes
```
i=input()
while i:print(end={i,i.upper()}.pop()[0]);i=i[1:]
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9M2M6@gtERDk6s8IzMnVSHTqqAoM69EIzUvxbY6UydTr7SgILVIQ7NWryC/QEMz2iBW0xqoJ9rQKvb/f4/UnJx8hfD8opwUAA "Python 3 – Try It Online")
*-4 bytes thanks to Chas Brown*
Uses `set.pop()` to randomize.
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 32 bytes
```
{,/{`c$x-32*1?2*(x<123)*x>96}'x}
```
[Try it online!](https://tio.run/##BcHrCkAwAAbQV/lcCovJVoqER7HYSi6T7cckzz7nbIXevFftm5fvNMeu4IxUAyOp6yrGM@L6pv4S93mF0D6XxHpC4Bbnog8c0hhohVlcqxU7dmmtvA2lFMEwRqH/AQ "K (oK) – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), ~~80~~ ~~78~~ 58 bytes
```
func[s][foreach c s[prin do pick[c[uppercase c]]random 2]]
```
[Try it online!](https://tio.run/##Jcw9CgIxEAbQfk/xkV7U2HkM22GKMD@6uGZC4uLxI@I7wOum82ZKvPRSNV7HYaao8Vn8iul7FRpMHt2KPCAY1PpaoYG2ypOE9tasSxkGYf4fyMxzi2jIJ3IkCbXDPTbHOV8SfsEbKfH8Ag "Red – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-m`](https://codegolf.meta.stackexchange.com/a/14339/), 5 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
c^HÑö
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW0&code=Y15I0fY&input=ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6Ig)
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-m`](https://codegolf.meta.stackexchange.com/a/14339/), 4 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
+u)ö
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW0&code=K3Up9g&input=ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6OiwuLiwuLCI)
```
-m //Map all characters in input
+ //Input prepended to
u) //Input to uppercase
ö //Random character
```
[Answer]
# [Python 2](https://docs.python.org/2/), 72 bytes
```
lambda i:"".join(choice(x)for x in zip(i,i.upper()))
from random import*
```
[Try it online!](https://tio.run/##DYsxDsMgDAD3vsJigqrK0LFSf9KFEBCuwLbAUZJ@njKdTrqTSzPTc6T3ZxRf180DvoxZvoxkQ2YM0Z4ucYMTkOCHYvGByy4Sm3XO3VLjCs3TNoFVuOl9SENSSNZojvOSXeHAUsCXw18d1gi9@uklqsbWYd7QxYfYZ6cZZKegu1dkAqZyLcaNPw "Python 2 – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~60~~ ~~46~~ 43 bytes
-3 bytes thanks to mazzy
```
-join($args|%{"$_"|%('t*g','*per'|random)})
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmZb/V83Kz8zT0MlsSi9uEa1WkklXqlGVUO9RCtdXUddqyC1SL2mKDEvJT9Xs1bzfy0Xl0qxgq2CEkh7vkJ5flFOip4Sl5pKmoJDMZT6DwA "PowerShell – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
żŒuX€
```
[Try it online!](https://tio.run/##y0rNyan8///onqOTSiMeNa35//9/Tn55alFyYnEqAA "Jelly – Try It Online")
Stolen from totallyhuman's solution to [Random Capitalization](https://codegolf.stackexchange.com/a/149512/85334).
My original solution, since I forgot Jelly has `ż`:
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
Œu,X¥"
```
[Try it online!](https://tio.run/##y0rNyan8///opFKdiENLlf7//5@TX55alJxYnAoA "Jelly – Try It Online")
[`,ŒuXƊ€`](https://tio.run/##y0rNyan8/1/n6KTSiGNdj5rW/P//Pye/PLUoObE4FQA) works for the same byte count.
```
" For every element of the input and every corresponding element of
Œu the input capitalized,
,X¥ choose one or the other at random.
```
[Answer]
# [Perl 5](https://www.perl.org/), 22 bytes
```
s/./.5<rand?uc$&:$&/ge
```
[Try it online!](https://tio.run/##VY9BasNADEWv8hchq9RZZVMK3fUeiqOMp5WlYUau8eXryk4hFAQCSbz/VLjKZV3buTt3l7dKenuf@sPx9XA8J465jYzCVoQh@YvhBl8KIysIYin3JBhJlesJc/YBPZXsJA3k8IFx5ZRVsybYfR80VmftGRGGNpIIhN25NvA312UeuDJYGndQc0zt2RebKj7titx2FQolehIjIazkP/W0B22v2SgL@oE0hcX2WSD@dLtQC2YUobcbI5nc4@hhvOG4@WMz52DPWbsfK55N2/oi5eMX "Perl 5 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
⭆Ｓ‽⁺↥ι↧ι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaHjmFZSWQLgamjoKQYl5Kfm5GgE5pcUaoQUFqUXOicWpGplAGZ/8cjgPBKz///dIzcnJ11EIzy/KSVHk@q9blgMA "Charcoal – Try It Online") Link is to verbose version of code. Trivial modification of my answer to [Random Capitalization](https://codegolf.stackexchange.com/questions/149491).
[Answer]
# [Python 3](https://docs.python.org/3/), 94 bytes
```
s=input();from random import*;print("".join([i.upper() if randint(0,1)==1 else i for i in s]))
```
[Try it online!](https://tio.run/##HYpBCsMwDAS/InKySwkNPQa/pPQQsE1UbFlI8qGvd53CMHPY5a@djZ5jaEDibs7vWVoFOSjOYOUmdttZkMwty/ppSO6Fa2dO4jxg/l@v9XHffAgbpKIJEHKTaSTQt/dj2IkKk6MU0Hq5JLMkCrHHpD8 "Python 3 – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 59 bytes
```
x=>x.Select(l=>z.Next()<1?l.ToUpper():l);var z=new Random()
```
[Try it online!](https://tio.run/##bZBNT8MwDIbv/Aqrp1SMSlzZWg4IJC4c@BBnL7htwHWqxF3X/fmSdaAJiShSJDt63se28cpGNz8MYmHzeC9DRwG3TJuowUlTrf6pVXU578tqX7wQk1XDZXUonmivJt9c33Lx6t/6noLJbzhf7zDAoRQa4Rnlw3cmn9cX78EpmROuuPNiUU1tsug7gp58zwTsvgjUg049gRNAYN84iwwdilBYwei0BYu9U@QIqKAtwZYaJ5Kw4OulEEmUxBKkdIgdMgOTKoUItKMwjS0FAuJIBYhXGOL5nfwQ4NNvwcVFBZMSnokpIVnxX@pqCQrLrDyBbVGaZHGcLCF@dIuklpjpIlj/QdB4rtOnk/ERR1FPndEl9ugk@932cfOXWZans56/AQ "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~109~~ 46 bytes
Thanks to Johan du Toit for -63 bytes
```
f(char*s){for(;*s++-=(*s-97u<26&rand())*32;);}
```
[Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpKqYFNckpKZr5dhx4UilJOZBBT7n6aRnJFYpFWsWZ2WX6RhrVWsra1rq6FVrGtpXmpjZKZWlJiXoqGpqWVsZK1pXfs/NzEzT0OzmosTpEuhONrSMtaaizM9taRYo1gTyEqDUAWlUIHa/4kkAwA "C (gcc) – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~51~~ 50 bytes
```
for(;$l=$argn[$i++];)echo$l>_&&rand()%2?$l^' ':$l;
```
[Try it online!](https://tio.run/##VY/dTsMwDEZf5bso@9FGL7ikwO54CQTI69w2w7WjJKPqy1PSDmlCsmwpsc537Ds/PR187o2FTVXIc0Gh1bfC7Xbv1Zbrzgp5@VytAulps717OBTyscb6sZBqmqL1DM/mhSHui5EMafQMpyCIta4mQU@qHPYYXOpQk3eJJIISUsc4cutUnbawZnmIrIm1ZuRAxJ5EIJwShwj@5jAOHQcGS@QSagmXeJujXQLOdoSLiwplJboRc0K2kv/U/RI0n2e9jKg70jZbzJdlxJ9umdUyMxehthOjNWny0tV4xnFM15/BZfbgtPwxn5xpnO5ffwE "PHP – Try It Online")
---
# [PHP](https://php.net/), ~~51~~ 50 bytes
```
for(;$l=$argn[$i++];)echo rand()%2?ucfirst($l):$l;
```
[Try it online!](https://tio.run/##VY/BTsMwDIZf5T8UadPGDhwpaDdeAnHwMrcNuHaUuFR9eUq2IU1Ili0l1vd/TkNaX46p9s7ypm3ktaHc63sTd7uPdsthMGTS82b78HScQhdz8U0j2@dG2nUtNjISWxKGxC@GG3xJjKggiPUxkGAkVc57zNEHBErRSQrI4QPjxH1UjdrDuutDYXXWwKipKCOJQNidcwF/c17mgTODpfABao6p3OdiU8annRDLVYWqEt2JNaFayX/q/hp0udFGWRAG0r5aXC6riD/dQ1WrzFqEYGdGb9LVpZvxBcfFbz9zrOw56uHHkkfTsj6@/QI "PHP – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Why isn't it ending? [closed]](/questions/24304/why-isnt-it-ending)
(73 answers)
Closed 9 years ago.
Now that we have [over a hundred ways to get stuck in a loop](https://codegolf.stackexchange.com/questions/33196/loop-without-looping), the next challenge is to get out.
Specifically, write a piece of code with a (seemingly) infinite loop, but somehow manage to break out.
The "infinite loop" can be a statement like `while true`, `for (;1>0;)` or anything else which obviously lasts forever. Recursion does not count (since stack overflows will quickly occur).
To break out, you need to execute an instruction written just after the loop. You can not just exit the program or leave the method.
Valid answer (if only it somehow exited the loop):
```
while (true)
print("I'm stuck!")
print("I escaped!")
```
Invalid answer:
```
define loop() {
while (true)
print("I'm stuck!")
}
loop()
print("I escaped!")
```
[Answer]
# GolfScript
```
"0:1 Argentina - Germany":party~
{party puts 1}do
"Party is over."
```
[Try it online.](http://golfscript.apphb.com/?c=IjA6MSBBcmdlbnRpbmEgLSBHZXJtYW55IjpwYXJ0eX4Ke3BhcnR5IHB1dHMgMX1kbwoiUGFydHkgaXMgb3Zlci4i)
### How it works
```
"0:1 Argentina - Germany" # Push party string.
:party # Save string in party variable.
~ # Discard the string from the stack.
{ #
party # Push party string.
puts # Print string followed by a newline.
1 # Push a truthy conditional on the stack.
}do # Pop conditional from the stack and repeat the loop if truthy.
"Party is over." # Should never happen.
```
### Why is the party over?
>
> `~` not only discards he string; it evaluates it. Notably, it executes `0:1`. Since `1` is a valid identifier (which happens to have the default value `1`), this saves the value `0` in the variable `1`. Therefore, the loop's conditional will be falsy, so it is executed only once.
>
>
>
[Answer]
# C
Classic integer overflow.
```
#include<stdlib.h>
int main() {
unsigned a = 0;
unsigned b = 1000;
while (a<b) {
a++;
b++;
}
puts("Hi");
return 0;
}
```
[Answer]
# C/C++
The following program outputs
```
I'm stuck at 41...
I'm stuck at 18467...
I'm stuck at 6334...
I'm stuck at 26500...
I'm stuck at 19169...
I'm stuck at 15724...
I'm stuck at 11478...
I escaped at 29358!
```
(the output on your system may be different)
```
#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
jmp_buf b;
int my_location()
{
int result = rand();
if (result % 7 == 0)
longjmp(b, result);
return result;
}
int main()
{
int location = setjmp(b);
if (location)
return printf("I escaped at %d!\n", location);
for (;;)
{
printf("I'm stuck at %d...\n", my_location());
}
}
```
The "infinite" loop at the end of the `main` function is broken
>
> by the `longjmp` function, which is called when a random number becomes divisible by 7.
>
>
>
This is pretty standard... For people who are old enough to remember that trick (which was once pretty much the only way to implement this behavior in C).
[Answer]
## Befunge-98
This program breaks out of its infinite loop by randomly modifying itself
```
"ITRH"4(v
>222Sac*%Se3*%S5%S.pp
```
[Answer]
# C
Patricide
```
#include <stdio.h>
#include <unistd.h>
int main(void) {
pid_t id = fork();
if (id != 0) {
while(1) {
wait(1);
printf("Apples\n");
}
}
else {
wait(5);
kill(getppid(), 9);
}
printf("Bananas\n");
}
```
Fork a child process and enter an endless loop: child process terminates the parent process with a KILL signal.
[Answer]
## C
```
#include <stdio.h>
int i;
int main()
{
++i;
while(i)
{
i*=1000;
printf("%d",i);
}
}
```
[Answer]
# Java with SnakeYAML library used
Know your libraries :)
```
import java.util.ArrayList;
import java.util.List;
import org.yaml.snakeyaml.Yaml;
public class UnLoop
{
final static List<Object> queue = new ArrayList<>();
public static void main(String[] args)
{
//running serializer nonstatic
new Thread(()->{
for(;;){
if(queue.size()!=0)
System.out.println(new Yaml().dump(
queue.remove(0)));
}}).start();
queue.add("DERP");
queue.add(new String[]{"1","2","3","4"});
queue.add(new java.awt.Point(1, 1));
}
}
```
>
> Snakeyaml hates to serialize certain objects due to the way it works, java.awt.point is one of then, so it stackoverflows out
>
>
>
to satisfy the rule the loop is now a serializing thread and the data inerted from another thread
] |
[Question]
[
**Implement `String.prototype.toLowerCase()`**
**Description**
The `toLowerCase` method returns the value of the string converted to `lowercase`. toLowerCase does not affect the value of the string itself.
**Conditions**
Let count chars inside function and ignore all bootstrap code:
```
String.prototype.toLowerCase = function(){
// code that count here
}
```
Other languages are welcome but JavaScript implemantation is target of this question. Let's just focus on ASCII charachters .
Example input and output:
```
"sOmeText".toLowerCase(); => "sometext"
```
Example implementation:
```
String.prototype.toLowerCase = function(){
return this.split('').map(function(c){
var cc = c.charCodeAt(0);
if (cc > 64 && cc < 91) {
return String.fromCharCode(cc + 32);
}
return c;
}).join('');
}
```
[Answer]
## Javascript 70 68
Building from @grc's answer:
```
for(s=i='';c=this[i++];s+=(parseInt(c,36)||c).toString(36));return s
```
Convert character to integer then back (works since `Number.toString(36)` will always be lowercase)
Test case: <http://jsfiddle.net/Vh2TW/2/>
input:
```
console.log('ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~`-=_+{}[]:;\\\'\"<>,.?/!@#$%^&*()abcdefghijklmnopqrstuvwxyz'.toLowerCase())
```
output:
```
abcdefghijklmnopqrstuvwxyz1234567890~`-=_+{}[]:;\'"<>,.?/!@#$%^&*()abcdefghijklmnopqrstuvwxyz
```
**Update:** -2 characters, thanks @copy
[Answer]
## Bash, 10
Doesn't interface with javascript very well, but it works for everyday purposes.
```
tr A-Z a-z
```
Also, it's shorter than golfscript. (Booyah!)
---
**Example Input:**
```
echo "Hello World, asDFghJkL0123" | tr A-Z a-z
```
**Output:**
```
hello world, asdfghjkl0123
```
[Answer]
## Golfscript, 17
```
{..64>\91<*32*|}%
```
[Answer]
## J, 25
```
toLowerCase =: u:@(+32*91&>*64&<)@(3&u:)
```
Converting to numbers `(3&u:)` and back `u:` is quite uneasy.
[Answer]
## Javascript, 86
```
String.prototype.toLowerCase = function () {
s="";for(i=0;c=this.charCodeAt(i++);s+=String.fromCharCode(c>64&c<91?c+32:c));return s
};
```
[Answer]
## Python (45)
`l=lambda x:''.join(chr(ord(i)+('@'<i<'[')*32)for i in x)`
Pseudocode:
```
l=func(x) {
return toString( iterate(i in x) { chr(ord(i) + IsUppercase(i) * 32) } )
}
```
Explanation:
`('@'<i<'[')*32)`: `IsUppercase.` '@' - 64, 'A' - 65, 'Z' - 90, '[' - 91: If `64<ord(i)<91`, then return True and multiply it by 32 (to get `32`).
[Answer]
## VBA - 77 82
```
Function l(s)
'Counting only the stuff between Function and End
For x=1 To Len(s):m=Mid(s,x,1):l=l & IIf(m Like"[A-Z]",Chr(Asc(m)+32),m):Next
End Function
```
[Answer]
# Ruby: 32 characters
```
s.gsub(/[A-Z]/){($&.ord+32).chr}
```
Sample run:
(In 35 characters it can be made a method of `String` class, to work just as the JavaScript sample.)
```
irb(main):001:0> class String
irb(main):002:1> def toLowerCase
irb(main):003:2> self.gsub(/[A-Z]/){($&.ord+32).chr}
irb(main):004:2> end
irb(main):005:1> end
=> nil
irb(main):006:0> "sOmeText".toLowerCase
=> "sometext"
```
[Answer]
### javascript 76 chars:
```
replace(/[A-Z]/g,function(b){return String.fromCharCode(b.charCodeAt()+32)})
```
Here's the full function:
```
String.prototype.toLowerCase = function () {
return this.replace(/[A-Z]/g, function(b){
return String.fromCharCode(b.charCodeAt()+32)
});
}
```
[Answer]
# Julia, 49 chars
```
L(s)=ascii([s[i]+32(64<s[i]<91)for i=1:endof(s)])
```
for all chars s[i] if 64 < s[i] < 91 is true, add 32 to the ASCII character point (32\*true=32). If it’s false, then (32\*false=0), and nothing is changed.
example:
```
julia> str
"ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!@#abcdefghijklmnopqrstuvwxyz~"
julia> L(str)
"abcdefghijklmnopqrstuvwxyz1234567890!@#abcdefghijklmnopqrstuvwxyz~"
```
The default method in Julia is lowercase(str)
```
julia> lowercase(str)
"abcdefghijklmnopqrstuvwxyz1234567890!@#abcdefghijklmnopqrstuvwxyz~"
```
the difference in timing and memory allocation:
```
julia> @time L(str)
elapsed time: 1.0263e-5 seconds (792 bytes allocated)
julia> @time lowercase(str)
elapsed time: 6.693e-6 seconds (224 bytes allocated)
```
] |
[Question]
[
This is a slightly different code golf from the usual problems. I'm forced to work with Java at my workplace and I'm increasingly annoyed at what I must do to read a file into memory to a String so I can operate on it in a normal way.
The golf is this: What is the shortest possible function to dump a file into your language's smallest data structure of characters?
Java would be char[], C++ would be char\*, Haskell would be a [Char], etc. I don't care about complete programs or main() functions, but you do have to open and close the file.
>
> inb4 Unix's `>`
>
>
>
[Answer]
# C#
```
var a = System.IO.File.ReadAllText("filename.txt");
```
`a` is a string that will contain the contents of `filename.txt`
[Answer]
# PHP
```
$a=file('foo.txt');
```
`$a` now contains an array of strings of the lines of `foo.txt`.
Similarly:
```
$a=file_get_contents('foo.txt');
```
`$a` now contains a single string of the contents of `foo.txt`.
[Answer]
## Python
```
a=open('filename.txt').read()
```
The garbage collector will close the file.
[Answer]
## C (for unixoid systems)
```
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
/* inside a function */
struct stat fd_stat;
int fd;
void *buffer;
int fd = open("my.file",O_RDONLY);
if (fd<0) exit(EXIT_FAILURE);
fstat(fd,fd_stat);
buffer = mmap(NULL,fd_stat->st_size,PROT_READ,MAP_SHARED,fd,0);
if (buffer==NULL) exit(EXIT_FAILURE);
```
This ridiculously long piece of code creates a buffer `buffer` of length `fd_stat->st_size` that contains the file. You probably won't use C for code-golfing anyway..
[Answer]
### Scala
In Scala, you can get a iterator easily:
```
scala> io.Source.fromFile("Cg6367.scala").getLines
res274: Iterator[String] = non-empty iterator
```
then you can iterate over a collection of lines with a for loop, or use one of the other 200 methods, usable on iterators, like map, forall, filter, first, head, last, drop, groupBy, sortBy, ... - you name it. Simply outputting the content would be:
```
val ls = io.Source.fromFile("Cg6367.scala").getLines
println (ls.mkString ("\n"))
```
[Answer]
## J
```
a=.1!:1<'filename.txt'
```
`a` now contains a string representing the contents of `filename.txt`.
[Answer]
## C, 135 chars
Though 40 of those 135 chars are just because there are some `#include`s that you just can't skip:
```
#include<sys/mman.h>
#include<sys/stat.h>
```
(Add `fcntl.h` and `unistd.h` for non-golfing completeness.) Then in the place where the file contents are desired, it's as simple as:
```
struct stat s;char*p;int f=open("filename.txt",0);fstat(f,&s);
p=mmap(0,s.st_size,1,2,f,0);close(f);
```
The file is closed and `p` contains a pointer to the file contents. (Don't forget to call `munmap()` when you're done.)
[Answer]
# C
There's already a C answer, but this one uses nothing more than the absolute basics. It's also rather odd, and doesn't handle errors, because if users are going to give bad inputs really they deserve to have the program crash on them.
```
#include <stdlib.h>
#include <stdio.h>
**b,**m;main(l){
FILE*f=fopen("foo.txt","r");
for(m=b=malloc(64);~(l=fgetc(f));){
*b++=&l;
b=malloc(64);
}
return fclose(f);
}
```
Dumps the file into a linked list of chars, which if it's good enough for Haskell, it's good enough for C. Assumes a pointer is 32 bits and EOF is -1.
Clearly a linked list of ints is the most
[Answer]
# Ruby
* `a=File.open('foo.txt', 'r') { |f| f.read }`
* `a=IO.read('foo.txt')`
[Answer]
Clojure's slurp overload that doesn't take the encoding is deprecated (for good reason):
```
(slurp "a.txt")
```
Here's the way to specify the encoding
```
(slurp "a.txt" :encoding "UTF-8")
```
[Answer]
# Tcl
```
set t [read [open file.txt]]
```
[Answer]
# Groovy, 9 bytes, or 19
Closure expecting a File object:
```
{it.text}
```
Closure expecting a String filepath:
```
{new File(it).text}
```
[Answer]
# F#
```
let a = System.IO.File.ReadAllText("filename.txt")
```
`a` is a System.String that will contain the contents of `filename.txt`
[.NET family <3](https://codegolf.stackexchange.com/a/6372/15214)
[Answer]
# Java 7, 108 bytes (Method, Byte[])
```
public byte[] r(String p)throws Exception{return java.nio.file.Files.readAllBytes(new java.io.File(p).toPath());}
```
---
# Java 7, 125 Bytes (Method, String)
```
public String r(String p)throws Exception{return new String(java.nio.file.Files.readAllBytes(new java.io.File(p).toPath()));}
```
---
# Java, 193 bytes (Method, Lines)
Here's a java method that reads an entire file as a List of strings, one line means 1 string. Linebreaks [are detected as defined here](https://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html).
Boiler-plate:
```
public class A {
public static void main(String[] args) throws Exception {
List<String> lines = readLines(args[0]);
}
}
```
Method:
```
import java.util.*;public List readLines(String path)throws Exception{List l=new ArrayList();Scanner s=new Scanner(new java.io.File(path));while(l.add(s.nextLine())&&s.hasNextLine());return l;}
```
Ungolfed:
```
public List readLines(String path)throws Exception{
List l = new ArrayList();
Scanner s = new Scanner(new java.io.File(path));
while(l.add(s.nextLine())&&s.hasNextLine());
return l;
}
```
Ungolfed (With Best-Practices):
```
public static List<String> readLines(String path) throws FileNotFoundException {
List<String> l = new ArrayList<String>();
Scanner s = new Scanner(new java.io.File(path));
while(l.add(s.nextLine())&&s.hasNextLine());
s.close();
return l;
}
```
[Answer]
## Swift
```
import Foundation
let contents = try! String(contentsOfFile: "filename.txt")
```
[Answer]
# C, 110 bytes without filename
Another C answer. This one is very inefficient, but at least it is short. First is the header:
```
#import<stdio.h>
```
And then the code (`N` is the filename):
```
char*r,c;FILE*F=fopen(N,"r");for(int i=r=0;~(c=fgetc(F));r[i-1]=c)r=realloc(r,++i);fclose(F);
```
Assumes EOF is -1. `r` will be a pointer to the result block. (If `N` is empty file, then it will be a null pointer)
[Answer]
# q/kdb+, 9 bytes + filename
**Solution:**
```
a:read0`:filename.txt
```
`a` is now a list of lists; a list of chars for each line in `filename.txt`.
**Explanation:**
```
a:read0`:filename.txt / solution
`:filename.txt / path to the file, in this case filename.txt
read0 / read file as characters
a: / assign to variable a
```
Or we could drop to the `k` prompt we can do if we wanted to conserve some bytes:
```
\
a:0:`:filename.txt
```
[Answer]
# [Perl 5](https://www.perl.org/), 26 bytes
```
sub{local(@ARGV,$/)=@_;<>}
```
[Try it online!](https://tio.run/##K0gtyjH9r5Jmq6SfWpKsn1@sW5Sak5pYnKpkrVJk@7@4NKk6Jz85MUfDwTHIPUxHRV/T1iHe2sau9r@1SrytmkqRhkqapnVBUWZeyf9/@QUlmfl5xf91cwA "Perl 5 – Try It Online")
[Answer]
# [AutoHotkey](https://autohotkey.com/)
```
FileRead,a,foo.txt
```
`a` is a variable that now contains all the contents of the file `foo.txt` so long as that file is less than 1 GB. If file size or available memory is a problem, then you can loop through each line of a file instead using `Loop,Read,foo.txt`.
It has some options available such as limiting the read to the first `n` bytes or reading the file using a different file encoding so long as it's from a [standard list](https://msdn.microsoft.com/en-us/library/dd317756.aspx).
] |
[Question]
[
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.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly) on Linux, 6 bytes
```
5ịO×32
```
[Try it online!](https://tio.run/##y0rNyan8/9/04e5u/8PTjY3@//@vFGNobu7q4xZjGGOAAUFiRkBsHGOgAOFCqRgTqAojM2MtwxhjA4MYhxhjQ9MYIyDLwMDABKpSCQA "Jelly – Try It Online")
Usage note: the question says "write the shortest code you need to determine whether an executable binary program supplied as parameter", and that's exactly what you need to do here; supply the entire executable binary program as the parameter. Not its filename, the program itself. (I hope you have a fairly understanding shell!) The TIO link uses [the shortest known ELF program Linux will run, by Brian Raiter](http://www.muppetlabs.com/~breadbox/software/tiny/teensy.html) as the example program.
Linux uses ELF as its executable format. It turns out that the fifth byte of an ELF program specifies the processor bitwidth it's designed for: 0x01 for a 32-bit program, or 0x02 for a 64-bit program. So all we have to do is extract the byte in question (`5ị`), convert it from a character to a number (`O`), and multiply by 32 (`×32`).
There's probably a language that can use this exact algorithm more succinctly, but I wanted to post this answer to demonstrate the algorithm.
[Answer]
## GolfScript for ELF (5 bytes)
```
4=32*
```
## CJam for ELF (6 bytes)
```
q4=32*
```
or
```
q4=5m<
```
---
This is why I commented in the sandbox that "challenge" was not an appropriate description of this task.
[Answer]
# [Bash + common Linux utils](https://www.gnu.org/software/bash/), 18
* 2 byte saved thanks to @Dennis.
```
file -|cut -c17-18
```
The input program piped in.
[Try it online!](https://tio.run/##XY67DsIwFEP3@xUeGKAiiD4ESK3YYOUHWMLtKxJNUJqyUL49tChiYLN1bMs32beepUNR4HQ544iHNc2GSWmHTiq9nIW0Da/BrbSIosk8V3iRrdxgNbY5vWmqEjXMEF2ahAkI81VpEsgu@yO7jKg2Fq7q3eyhdGgEnKM0NL9b/CIjrr5W9wpi5MFBcLwX8cGXRlf@Aw "Bash – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL) (Linux), 5 bytes
```
5)32*
```
Implicitly input entire program. Get fifth byte, multiply by 32.
[Try it online!](https://tio.run/##y00syfn/31TT2Ejr//9o9YKi/HR1BcNYAA "MATL – Try It Online")
---
As a bonus, here's an answer that works on most (but not all) Windows executables, for 20 bytes:
```
t'PE'Xf1)4+)100=Q32*
```
[Try it online!](https://tio.run/##y00syfn/v0Q9wFU9Is1Q00Rb09DAwDbQ2Ejr//9o9YKi/PSixFygpIIBEKqnqMcCAA "MATL – Try It Online")
Find the `PE` signature (which would fail if there's an unusual DOS stub containing `PE`) and see if it is followed by `d` (100) two bytes later (which corresponds to x64, and thus would fail for other 64 bit architectures)
[Answer]
# Windows Bash (with core util?), test PE32 vs PE32+; 37 bytes
```
file $1|grep -q 2+&&echo 64||echo 32
```
This is a bash script works on Windows Bash (`bash` in Ubuntu Linux Subsystem on Windows 10), which tell given `*.exe` file 32 bit or 64 bit.
Not yet tested on other platform, maybe it work.
[Answer]
# Jelly (Windows), 24 bytes
```
ƈO
Ç64СUḣ4%⁹ḅ⁹_38ǹ¡×32
```
Hexdump:
```
00000000: 9c4f 7f0e 3634 0f00 55ed 3425 89d4 895f .O..64..U.4%..._
00000010: 3338 0e81 0011 3332 38....32
```
I have no idea why `%⁹` is necessary, but it is.
Takes the whole executable from STDIN. Take from command line argument would definitely shorter but there is a (small) upper bound on the size.
Yes, Windows PE executable format is hard to parse. Also Jelly hates non-constant nilad.
---
```
ƈO
```
Link 1: Return the next byte value from stdin.
```
Ç64СUḣ4%⁹ḅ⁹
```
Read the 4-byte [`e_lfanew`](https://stackoverflow.com/questions/47711282) at offset 60 and convert it to an integer.
```
_38ǹ¡
```
Take the byte at (e\_lfanew - 38) positions later which is the higher byte of the signature in the PE optional header, described [here](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680547(v=vs.85).aspx) at the "optional header magic number" part.
```
×32
```
Multiply by 32. Get 32 for 32-bit executables (PE32) and 64 for PE32+.
[Answer]
# [Haskell](https://www.haskell.org/), ~~36~~ 35 bytes
```
fmap((32*).fromEnum.(!!4)).readFile
```
For the ELF format
[Try it online!](https://tio.run/##BcHBDoMgDADQXymewERM5q54c1/hpWPUkRVsYPt9u/fe2D@JWSnsSgXF2uU2Ok/tLFv9FW@NuTvnW8LXI3PSgrlCAIJhfuY6cx9gXQNIy/WrVyTGo@sURf4 "Haskell – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-n`, 23 bytes
```
p IO.read($_)[4].ord*32
```
[Try it online!](https://tio.run/##KypNqvz/v0DB01@vKDUxRUMlXjPaJFYvvyhFy9jo/3/90uIi/aTMPP0ioDrd3KLMf/kFJZn5ecX/dfMA "Ruby – Try It Online")
Linux ELF version. TIO link tests the interpreter on itself.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 36 bytes
```
cp $1 x
file x|egrep -o '32|64'|uniq
```
[Try 64 bits online!](https://tio.run/##S0oszvj/P7lAQcVQoYIrLTMnVaGiJjW9KLVAQTdfQd3YqMbMRL2mNC@z8D9YEqjMTkE/JbVMv7gkJbWo6P9//dLiIv2kzDz9gsqSjPw8Iz1zAA "Bash – Try It Online")
[Try 32 bits online!](https://tio.run/##S0oszvj/P7lAQcVQoYIrLTMnVaGiJjW9KLVAQTdfQd3YqMbMRL2mNC@z8D9YEqjMTkE/JbVMv7gkJbWo6P9//dLiIv2czCT95MzEfDCha6hnaKKfmpeemZcKFoAw9Xw8/UIjMi3MAA "Bash – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Rotate simple ASCII art [closed]](/questions/20154/rotate-simple-ascii-art)
(11 answers)
Closed 9 years ago.
Given an input of a 2 dimensional array of integers, rotate the array 90 degrees clockwise.
It should work for rectangular arrays of all sizes and proportions.
The rotated array should be printed at the end of the program.
**Example:**
Input:
```
[[0,1,2,3,4,5],
[6,7,8,9,0,1],
[2,3,4,5,6,7],
[8,9,0,1,2,3]]
```
Output:
```
[[8,2,6,0],
[9,3,7,1],
[0,4,8,2],
[1,5,9,3],
[2,6,0,4],
[3,7,1,5]]
```
Do not rely on the patterns in the arrays above, they were used just for explanation purposes. Expect the arrays to be randomly generated.
**Scoring**
Every character in the program counts as **1 point**.
The first line of the program can store the array as a variable for **0 points**. The array must be stored as-is without any changes made to it until after this first line.
If your code can rotate other multiples of 90 degrees, **-15 points** from your score. If this value must be stored, it can be done so at the beginning of the program for **0 points**. It can be supplied in the same way that the array is supplied.
Lowest score wins!
[Answer]
## Python 2 (17=32-15) (19)
No input (19):
```
s = [[0,1,2,3,4,5],
[6,7,8,9,0,1],
[2,3,4,5,6,7],
[8,9,0,1,2,3]]
print zip(*s[::-1])
```
Taking input in `t`, the number of rotations (17=32-15)
```
s = [[0,1,2,3,4,5],
[6,7,8,9,0,1],
[2,3,4,5,6,7],
[8,9,0,1,2,3]]
t=3
exec"s=zip(*s[::-1]);"*t
print s
```
[Answer]
# J 11 9 7 -10 = -3
```
|:&|.^:
```
*Edit:* Changing argument order gets rid of the parentheses.
*Edit 2:* Reducing by 2 characters by swapping rows instead of columns, and inverting the order of operations.
Adverb taking the multiple of 90 degrees, then the array to rotate.
```
NB. needs assigning to a variable or parentheses to separate from the arguments.
rot =: |:&|.^:
]a =: i. 4 4
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
|:&|.^: 1 a
12 8 4 0
13 9 5 1
14 10 6 2
15 11 7 3
|:&|.^: 2 a
15 14 13 12
11 10 9 8
7 6 5 4
3 2 1 0
|:&|.^: 3 a
3 7 11 15
2 6 10 14
1 5 9 13
0 4 8 12
|:&|.^: 4 a
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
```
Try it yourself at [tryj.tk](http://tryj.tk)
As a little extra, this extends to any rank at the cost of 1 char, when slightly changed to
```
rot =: (|:|.)^:
```
This way it takes the permutation order for the transpose to the left, and the number of flips and the array to the right. Depending on the axis permutation requested, you get back after a number of flips: flipping two axis makes you come back after 4 turns, shifting the axis makes you come back after 2 times the rank of the array.
```
]b=:i.2 3 4
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
16 17 18 19
20 21 22 23
0 2 1 (|:|.)^: 1 b
12 16 20
13 17 21
14 18 22
15 19 23
0 4 8
1 5 9
2 6 10
3 7 11
1 2 0 (|:|.)^: 6 b
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
16 17 18 19
20 21 22 23
```
[Answer]
### Ruby — 34 - 15 = 19
```
m = [[0,1,2,3,4,5],
[6,7,8,9,0,1],
[2,3,4,5,6,7],
[8,9,0,1,2,3]]
n = 1
n.times{m=m.reverse.transpose};p m
```
### Haskell — 55 - 15 = 40
```
let m = [[0,1,2,3,4,5],[6,7,8,9,0,1],[2,3,4,5,6,7],[8,9,0,1,2,3]]
let n = 1 :: Int
import Data.List
print$(iterate(transpose.reverse)m)!!n
```
[Answer]
# Javascript (*ES6*) 51 48 45
Alerts each row of the new rotated array in sequence.
```
a = [[0,1,2,3,4,5],
[6,7,8,9,0,1],
[2,3,4,5,6,7],
[8,9,0,1,2,3]]
for(i in a[0])alert(a.map(j=>j[i]).reverse())
```
] |
[Question]
[
Given a specific date, have the code output a relative reference:
1. If the date entered is ahead of the current date, express as "x days from now" or "x weeks, y days from now", or "x years, y weeks, z days from now". Zero units need not be mentioned.
2. If the date is the current simply have it output "Today"
3. If the date entered is earlier than the current date, express as "x days ago" or "x weeks, y days ago", or "x years, y weeks, z days ago". Zero units need not be mentioned.
Smallest solutions are the winners here...
Good luck!
[Answer]
# R, 102, 98
## (kinda cheating: literal interpretation of the question)
```
cat(if(x<-as.Date(readline())-Sys.Date())c(abs(x),"days",c("from now","ago")[(x<0)+1])else"today")
```
Examples:
```
2013-12-08
today
2010-01-13
1425 days ago
2015-12-2
724 days from now
```
[Answer]
# Ruby, kinda cheating - 89, less cheaty - 140
## Kinda cheating, 89
```
f=->d{i=((d-Time.now)/86400).ceil;["Today","#{-i} days ago","#{i} days from now"][0<=>i]}
```
It's a function that takes the date as an argument and returns the string.
Examples:
```
irb(main):036:0> f[Time.new(2013, 12, 1)]
=> "7 days ago"
irb(main):037:0> f[Time.new(2013, 12, 10)]
=> "2 days from now"
irb(main):038:0> f[Time.new(2013, 12, 8)]
=> "Today"
irb(main):039:0> f[Time.new(2011, 10, 8)]
=> "792 days ago"
```
Hey, you never said we couldn't use only days!
>
> express as "x days from now" **or** "x weeks, y days from now", **or** "x years, y weeks, z days from now". [emphasis mine]
>
>
>
Well, I choose the first one :P Abusing the rules is so fun!
## Less cheaty, 140
```
f=->d{t=Time.new
a=((d-t)/86400).ceil
g='from now'
a,g=-a,'ago'if a<0
a==0?'Today':"#{a/365} years, #{a%365/7} weeks, #{a%365%7} days #{g}"}
```
Examples:
```
irb(main):111:0> f[Time.new 2013, 12, 10]
=> "0 years, 0 weeks, 2 days from now"
irb(main):112:0> f[Time.new 2013, 12, 17]
=> "0 years, 1 weeks, 2 days from now"
irb(main):113:0> f[Time.new 2014, 12, 17]
=> "1 years, 1 weeks, 2 days from now"
irb(main):114:0> f[Time.new 2012, 12, 17]
=> "0 years, 50 weeks, 6 days ago"
irb(main):115:0> f[Time.new 2012, 1, 1]
=> "1 years, 48 weeks, 6 days ago"
irb(main):116:0> f[Time.new 2013, 12, 8]
=> "Today"
```
It said
>
> Zero units need not be mentioned.
>
>
>
But you never said they **can**not be mentioned.
[Answer]
## JavaScript, 146
Input is a timestamp as number of milliseconds from 1970-01-01 (Unix timestamp × 1000), since this makes things more conventient for me (and no input format was specified).
```
D=new Date-prompt()
d=Math.abs(D/864e5)
e=d%365%7|0
alert(e?[d/365|0,"years,",d%365/7|0,"weeks,",e,"days",D>0?"ago":"from now"].join(" "):"Today")
```
[Answer]
## C - 348
First CodeGolf post, so I figured that I would have fun with it.
```
#include<time.h>main(int a,char *v[]){a--;struct tm t={0};char* n=strtok(v[1],"/");while(n!=0){switch(a++){case 1:t.tm_mon=atoi(n)-1;case 2:t.tm_mday=atoi(n);case 3:t.tm_year=atoi(n)-1900;}n=strtok(0,"/");}a=(int)difftime(time(0),mktime(&t))/86400;printf("%s\n",a=0?"today":(a>0?strcat(itoa(a)," days ago"):strcat(itoa(abs(a))," days from now")));}
```
Ungolfed:
```
#include <time.h>
main (int a,char *v[])
{
a--;
struct tm t={0};
char* n=strtok(v[1],"/");
while(n!=0)
{
switch(a++)
{
case 1:t.tm_mon=atoi(n)-1;
case 2:t.tm_mday=atoi(n);
case 3:t.tm_year=atoi(n)-1900;
}
n=strtok(0,"/");
}
a=(int)difftime(time(0),mktime(&t))/86400;
printf("%s\n",a=0?"today":(a>0?strcat(itoa(a)," days ago"):strcat(itoa(abs(a))," days from now")));
}
```
---
Test runs:
```
$ ./date 12/8/2013
1 days ago
$ ./date 12/10/2013
1 days from now
$ ./date 12/9/2013
today
```
[Answer]
## Python 2 - 134
This is a bit abusive as this assumes the objects given is a `datetime.date()` object. But you did say it would be given as a date, so...
```
from datetime import*
D=input()
t=datetime.now().date()
w=str(D-t).split(',')[0]
print[w[1:]+" ago","today",w+" from now"][cmp(D,t)+1]
```
] |
[Question]
[
Given the following test, implement an `addOne` function in C# so it passes, without any modification to the test. TIP: Yes, it is possible.
```
[TestMethod]
public void TheChallenge()
{
int a = 1;
addOne(a);
Assert.IsTrue(a == 2);
}
```
**EDIT:** clarified the Assert to avoid confusion. The value of `a` should be 2; there's no trick there.
[Answer]
Ummm, simply provide an implementation of AssertTrue that doesn't throw anything?
```
void addOne(int a){}
void AssertTrue(bool b) { }
```
You never specified what testing framework is used here. It looks like MSTest, but I fired up a new test project and AssertTrue doesn't exist, so I took the liberty of implementing it myself.
# EDIT
This solution might be what you were fishing for:
```
void addOne(int x)
{
unsafe
{
int* i = &x;
i += 4;
*i += 1;
}
}
```
I feels pretty fragile, but it works on my box consistently. It probably depends heavily on the compiler, so hopefully it is reproducible elsewhere.
] |
[Question]
[
**This question already has answers here**:
[Am I perfect (number)?](/questions/58026/am-i-perfect-number)
(20 answers)
[Am I a Sophie Germain prime? [duplicate]](/questions/131604/am-i-a-sophie-germain-prime)
(28 answers)
[Test a number for narcissism](/questions/15244/test-a-number-for-narcissism)
(77 answers)
[Is it a Mersenne Prime?](/questions/104508/is-it-a-mersenne-prime)
(38 answers)
[Test if a given number is a Vampire Number [duplicate]](/questions/125/test-if-a-given-number-is-a-vampire-number)
(2 answers)
Closed 6 years ago.
>
> Six is a number perfect in itself, and not because God created all things in six days; rather, the converse is true. God created all things in six days because the number six is perfect.
>
>
>
I am fascinated by numbers. As were [Sophie Germain](https://en.wikipedia.org/wiki/Sophie_Germain) and [Marin Mersenne](https://en.wikipedia.org/wiki/Marin_Mersenne). To be more specific, these two were fascinated by *primes*: a number with only two integer divisors: itself and `1`. In fact, they were so fascinated by primes that classes of primes were named after them:
A Mersenne prime is a prime number which can be generated by the formula 2p - 1 where `p` is a prime. For example, `7 = 2^3 - 1` therefore `7` is a Mersenne prime.
A Germain prime is similar. It is a prime number that when plugged into the formula `2p + 1` it also produces a prime. E.g. 11 is Germain as `2*11 + 1 = 23` which is prime.
But now let's move on to the next three numbers: perfect, vampire and narcissistic numbers.
A perfect number is very easy to understand. It can be easily defined as
>
> A number where all its divisors except itself sum to itself. For example, 6 is a perfect number as the divisors of 6 (not including 6) are 1,2,3 which sum to make 6.
>
>
>
A vampire number may be the most difficult to code. A vampire number is a number whose digits can be split into two numbers, of equal length, made from *all* those digits, that when multiplied, produce the original number. Leading 0s aren't allowed in either of the numbers E.g. `136,948 = 146 x 938`
Finally a narcissistic number, probably the hardest to understand. A narcissistic number is a number in which the individual digits, raised to the power of the total number of digits sum to make the original number. A single digit number **has to be** narcissistic.
For example, 8,208 is narcissistic:
84 + 24 + 04 + 84 = 4,096 + 16 + 0 + 4,096 = 8,208
Your task is to create a program that will take an integer and return what category it fits into. The categories are `Mersenne`, `Germain`, `Perfect`, `Vampire`, `Narcissistic` and `False`. Every number that doesn't fit into the first five categories is `False`. `False` doesn't have to necessarily be a falsy value.
If a value fits in more than one category, e.g. `3`, you may output **any** correct result.
Output can be in any form, for example, 6 different numbers, as long as you say what it is in your answer.
Even if it is shorter, you aren't allowed to hard code each number as that ruins maths.
This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code wins!
## Examples
```
Input -> Output
10 -> False
7 -> Mersenne
8208 -> Narcissistic
28 -> Perfect
153 -> Narcissistic
2 -> Germain
17 -> False
16,758,243,290,880 -> Vampire
31 -> Mersenne
33,550,336 -> Perfect
173 -> Germain
136,948 -> Vampire
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~43~~ ~~40~~ 39 bytes
```
Lo<¹å¹p&¹·>p¹p&¹Ñ¨OQ¹œε2ä}P¹å¹S¹gmOQ)Xk
```
`-1` for False, `0` for Mersenne, `1` for Germain, `3` for Perfect, `4` for Vampire, and `5` for Narcissistic.
[Try it online!](https://tio.run/##MzBNTDJM/f/fJ9/m0M7DSw/tLFA7tPPQdrsCCOvwxEMr/AMP7Tw6@dxWo8NLagMgioIP7UzP9Q/UjMj@/98cAA "05AB1E – Try It Online")
[Answer]
# [Pyth](https://pyth.readthedocs.io), 71 bytes
```
x[.EmqQ*shdsed.cs.pM.cK`Q/lK2 2qsP{*MyPQQ&P_hyQP_Q<.&QhQP_QqQsm^sdlKK)1
```
**[Try it here!](https://pyth.herokuapp.com/?code=x%5B.EmqQ%2ashdsed.cs.pM.cK%60Q%2FlK2+2qsP%7B%2aMyPQQ%26P_hyQP_Q%3C.%26QhQP_QqQsm%5EsdlKK%291&input=28&test_suite_input=10%0A7%0A8208%0A28%0A153%0A2%0A17%0A31%0A173%0A136948&debug=0) or [Verify the test cases.](https://pyth.herokuapp.com/?code=x%5B.EmqQ%2ashdsed.cs.pM.cK%60Q%2FlK2+2qsP%7B%2aMyPQQ%26P_hyQP_Q%3C.%26QhQP_QqQsm%5EsdlKK%291&input=10&test_suite=1&test_suite_input=10%0A7%0A8208%0A28%0A153%0A2%0A17%0A31%0A173%0A136948&debug=0)**
Alternative solution, **71 bytes:**
```
x[.EmqQ*shdsed.cs.pM.cK`Q/lK2 2qsP{*MyPQQ&P_hyQP_Q&.AjQ2P_QqQsm^sdlKK)1
```
**[Try it here!](https://pyth.herokuapp.com/?code=x%5B.EmqQ%2ashdsed.cs.pM.cK%60Q%2FlK2+2qsP%7B%2aMyPQQ%26P_hyQP_Q%26.AjQ2P_QqQsm%5EsdlKK%291&input=10&test_suite_input=10%0A7%0A8208%0A28%0A153%0A2%0A17%0A31%0A173%0A136948&debug=0) or [Verify the test cases.](https://pyth.herokuapp.com/?code=x%5B.EmqQ%2ashdsed.cs.pM.cK%60Q%2FlK2+2qsP%7B%2aMyPQQ%26P_hyQP_Q%26.AjQ2P_QqQsm%5EsdlKK%291&input=10&test_suite=1&test_suite_input=10%0A7%0A8208%0A28%0A153%0A2%0A17%0A31%0A173%0A136948&debug=0)**
This returns **-1** for *False*, **0** for Vampire, **1** for *Perfect*, **2** for *Sophie Germain*, **3** for *Mersenne* and **4** for *Narcissistic*. In case more are truthy, this picks the one with the lowest index. Unfortunately, this memory errors for the following test cases: `33550336, 16758243290880`.
---
# Explanation
## Vampire (29 bytes)
```
.EmqQ*shdsed.cs.pM.cK`Q/lK2 2
.c `Q/lK2 Get all combinations of the input's digits of half its length.
.pM Get all possible permutations of each.
.cs 2 Get all possible two-number combinations, flattened.
.EmqQ*shdsed Check if any has the product equal to the input.
```
Let's go through an example. Let's assume our input is **1260**.
* First of all, we get the all the possible combinations of 2 digits (number\_of\_digits / 2). We get `['12', '16', '10', '26', '20', '60']`.
* Then, we get the possible permutations of each, `[['12', '21'], ['16', '61'], ['10', '01'], ['26', '62'], ['20', '02'], ['60', '06']]`.
* We flatten that (`['12', '21', '16', '61', '10', '01', '26', '62', '20', '02', '60', '06']`) and get all the possible 2-element combinations. This list is quite long:
```
[['12', '21'], ['12', '16'], ['12', '61'], ['12', '10'], ['12', '01'], ['12', '26'], ['12', '62'], ['12', '20'], ['12', '02'], ['12', '60'], ['12', '06'], ['21', '16'], ['21', '61'], ['21', '10'], ['21', '01'], ['21', '26'], ['21', '62'], ['21', '20'], ['21', '02'], ['21', '60'], ['21', '06'], ['16', '61'], ['16', '10'], ['16', '01'], ['16', '26'], ['16', '62'], ['16', '20'], ['16', '02'], ['16', '60'], ['16', '06'], ['61', '10'], ['61', '01'], ['61', '26'], ['61', '62'], ['61', '20'], ['61', '02'], ['61', '60'], ['61', '06'], ['10', '01'], ['10', '26'], ['10', '62'], ['10', '20'], ['10', '02'], ['10', '60'], ['10', '06'], ['01', '26'], ['01', '62'], ['01', '20'], ['01', '02'], ['01', '60'], ['01', '06'], ['26', '62'], ['26', '20'], ['26', '02'], ['26', '60'], ['26', '06'], ['62', '20'], ['62', '02'], ['62', '60'], ['62', '06'], ['20', '02'], ['20', '60'], ['20', '06'], ['02', '60'], ['02', '06'], ['60', '06']]
```
* The next step is getting the product of each pair:
```
[252, 192, 732, 120, 12, 312, 744, 240, 24, 720, 72, 336, 1281, 210, 21, 546, 1302, 420, 42, 1260, 126, 976, 160, 16, 416, 992, 320, 32, 960, 96, 610, 61, 1586, 3782, 1220, 122, 3660, 366, 10, 260, 620, 200, 20, 600, 60, 26, 62, 20, 2, 60, 6, 1612, 520, 52, 1560, 156, 1240, 124, 3720, 372, 40, 1200, 120, 120, 12, 360]
```
* And then compare to the input:
```
[False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, True, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False]
```
* Finally, the last step is checking if any value is truthy. And there is one (at index `19` into the list). Hence, this returns a truthy value for **1260**, thanks to the pair **[21, 60]**.
## Perfect (10 bytes)
```
qsP{*MyPQQ
q Q Is equal to the input?
s Sum.
{*MyPQ Its divisors.
P Popped (since we want the proper divisors).
```
## Sophie Germain (9 bytes)
```
&P_hyQP_Q
P_Q Is the input prime?
P_hy Is the input doubled + 1 prime?
& Logical AND.
```
## Mersenne (9 bytes)
```
<.&QhQP_Q
< Is smaller?
.& Bitwise AND between:
Q The input
hQ And the input + 1
than:
P_Q Is the input prime?
```
This tests if the **input + 1** is a power of two (i.e. if it is a Mersenne number), and then performs the primality test. In Python, `bool` is a subclass of `int`, so truthy is treated as **1** and falsy is treated as **0**. To avoid checking explicitly that one is **0** and the other is **1**, we compare their values using `<` (since we only have 1 such case).
In the alternative approach, this part is changed to `&.AjQ2P_Q`. This works as follows:
```
&.AjQ2P_Q
jQ2 The input in binary as a list of digits.
.A Are all truthy (i.e equal to 1)?
& P_Q ... And is prime?
```
This uses the fact that any number of the form **2n - 1** only consists of **1** when written in binary, and also checks if it is prime.
## Narcissistic (10 bytes)
```
qQsm^sdlKK
q Is equal?
Q The Input
m K Map over the string representation of the input.
^sdlK Raise each digit to the power of the number of digits the input has.
s Summed.
```
---
When it comes to the rest of the code, `[...)` builds a list of bool values and `x[...)1` gets the index of the first truthy element.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 53 bytes
```
“+1l2Ḟ⁼¡Ḟ$ÆPȧÆP“_1HÆPȧÆP“ÆḌS⁼“DŒ!œs€2ḌP€ċ“D*L$S⁼”v€TX
```
[Try it online!](https://tio.run/##y0rNyan8//9RwxxtwxyjhzvmPWrcc2ghkFY53BZwYjmQAErFG3og8Q63PdzREwxUB2S7HJ2keHRy8aOmNUC9PQFA@kg3SFjLRwWiYm4ZUCwk4v///0bGAA "Jelly – Try It Online")
Returns `1` for Mersenne, `2` for Germain, `3` for Perfect, `4` for Vampire, `5` for Narcissistic and `0` for False. Returns random in case many are true.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 51 bytes
```
"p¹p* "D">2.nDîpsïÿ<;ÿѨOQ œε2ä}P¹å s¹gmOQ"#ε.V}ā*à
```
[Try it online!](https://tio.run/##AU8AsP8wNWFiMWX//yJwwrlwKiAiRCI@Mi5uRMOucHPDr8O/PDvDv8ORwqhPUSDFk861MsOkfVDCucOlIHPCuWdtT1EiI861LlZ9xIEqw6D//zIz "05AB1E – Try It Online")
Returns `1` for Mersenne, `2` for Germain, `3` for Perfect, `4` for Vampire, `5` for Narcissistic and `0` for False. Returns max in case many are true.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~292~~ ~~286~~ 274 bytes
*-2 bytes thanks to [@Okx](https://codegolf.stackexchange.com/users/26600/okx)*
*-4 bytes thanks to [@Mr.Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder)*
```
lambda n:[n&-~n<a(n),a(n)&a(2*n+1),sum(k*(n%k<1)for k in range(1,n))==n,any(len(c)%2<1<n==int(j(c[::2]))*int(j(c[1::2]))for c in permutations(`n`)),sum(int(d)**len(`n`)for d in`n`)==n,1].index(1)
a=lambda n:all(n%k for k in range(2,n))*~-n>0
j=''.join
from itertools import*
```
[Try it online!](https://tio.run/##XVDBbsIwDL33K3yBJl1ApGyMVYQfYZXI2pQFWrdKwjSE4NdZDNoOkxLbz7GfnzOcwmeP@a1R77dWdx@1Biw2OJ5ccaUZckFmrFme4ZPkwh87dsgYjg4ryZvewQEsgtO4M0wK5FwpFBpPrDXIKj7KV3KFSlkMbM@qTVHkJefZL5QPTDwV8QzGdcegg@3Rsy1u@WMgldc8y4iTslRfx3qKaZ4spxZr880kT7T620K3LQmFfzJzkpldJ7ieJXuVptN9bzFpXN@BDcaFvm892G7oXchuzvhjGzwo2KSdcd4gmlSkuyhUW4xRlNyYKsToS3eDdfSK2lXWe@uDrSJsdOtNWibB@AeTnAl4FbDMZ0sBebzyZR6D6GN2LslHLOeLt@dlmSSkn3pphTtHkQC4SNQwgjyiwcU/gvRcLC4wWcP5AopsOo29nQ73OgEunsc@G1fy2w8 "Python 2 – Try It Online")
Output is `0` for mersenne, `1` for germaine, `2` for perfect, `3` for vampire, `4` for narcissistic and `5` for false.
---
## Ungolfed
```
from itertools import*
f=lambda n:
[
n&-~n == 0 and a(n), # Is n a Mersenne prime?
a(n) and a(2*n+1), # Is n a Germain prime?
sum(k for k in range(1,n) if n%k<1)==n, # Is n a perfect number?
any(len(c)%2<1< # Is n a vampire number?
n==int(''.join(c[:len(c)/2]))*int(''.join(c[len(c)/2:]))
for c in permutations(`n`)),
sum(int(d)**len(str(n)) for d in str(n))==n, # Is n a narcissistic number?
1
].index(1) # Get the first position
# of a 1 (or True) in the list
a=lambda n:False if n<2 else all(n%k for k in range(2,n)) # primality check
```
[Answer]
# Mathematica, 275 bytes
```
If[!FreeQ[(S=Select)[2^Range@#-1,PrimeQ],#],1,If[!FreeQ[S[Prime@Range@#,PrimeQ[2#+1]&],#],2,If[PerfectNumberQ@#,3,If[!FreeQ[Times@@FromDigits/@#&/@S[Subsets[Tuples[v=(j=IntegerDigits)@#,{(k=IntegerLength)@#/2}],{2}],ContainsAll[Flatten@#,v]&],#],4,If[Tr[j@#^k@#]==#,5,6]]]]]&
```
thanx to @Mr. Xcoder for letting me know that I don't have to use the string-names!
] |
[Question]
[
* Mike Bufardeci (Pyth) - 175 bytes
* Leo (Retina) - 175 bytes
* devRicher (Lua) - 182 bytes
* Peter Taylor (CJam) - Waiting for clarification
* Lyth (C++11) - Waiting for clarification
---
**Edit: Several changes made, should not affect any already submitted answers.**
**Edit #2: Very few people are taking advantage of the 1024 byte limit. The point of this challenge is to output code golf answers, not things like the example at the bottom of this post.**
**Edit #3: Here is the paragraph to test against: `WASHINGTON - These are chaotic and anxious days inside the National Security Council, the traditional center of management for a president's dealings with an uncertain world.` I will test the submissions myself later.**
At PPCG, we pride ourselves in writing programs to solve problems. However, it's very time consuming to write the programs to solve problems. Instead we should write programs to write programs to solve problems!
In this case, the problem is Kolmogorov Complexity. You must write a program that golfs a program, that outputs piece of text.
Main program -> Generated program -> Text
You do not necessarily need to golf the main program. Your score is the length of the generated program.
---
You will not know the final text when writing the main program. Therefore, you will not be able to write the generated program by hand. The main program should take a string input and create the generated program, which correctly outputs the text.
---
On February 12th, the first paragraph of the headline of the New York Times will be used for scoring. I will post the article at 10 AM ESThttps://www.nytimes.com/
---
* You may use any language for the main program and generated program. They do not have to be the same.
* The final text will never contain these characters: `", ', \n, \r`.
* The main program is limited to 1024 bytes (not characters). The generated program has no byte limit, as long as it outputs the text.
* Compression algorithms built in to your language are not allowed (both ways), unless you code it from scratch. This includes any type of text compression libraries, and base conversion. This does not include Regexes.
* Standard loopholes apply.
---
Example: (JavaScript)
```
f=(g)=>{console.log("console.log('" + g + "')")}
```
[Answer]
## CJam, Burrows-Wheeler transform and run-length encoding
I think it's stupid to ban builtins for base-conversion as "compression", but I've implemented my own, as well as implementing run-length encoding and decoding manually rather than using the builtin.
```
q
e# Reduce range, add start-of-message marker
[0\:i_:e<(:If-+
e# Burrows-Wheeler transform
_,({_(+}*]$Wf=
e# RLE without e`, decrementing each runlength for compactness
0\{_2$={;\)}0?\}%\;2/
e# Pair [runlength-1 ch] to a single int
_1f=:e>):Paf{.*1b}
e# Base-convert to the minimal possible base
_:e>):B;W%{\B*+}*
e# Base-convert to base 256
[{256md\}h;]W%
e# Format as a string literal with as few special cases as possible
:c'"\'"/"\\\""*'"
e# Decoder base-converts to base 256, then base B, unpairs, run-length decodes, and
e# inverse Burrows-Wheeler transforms
":i{\256*+}*{"B"md"P"mda\)*\}h;]e_:A,Ma*_,{A\.+$}*0=(;"I"cf+"
```
* `I` is the increment which must be added to each decoded value
* `P` is the base used to combine run-length with char
* `B` is the base used to convert the whole thing
[Answer]
# Pyth, worst case `length(input) + 1` bytes
```
=kNJ++kzkV92Iq/zC+32N0 aYC+32N))V.:z7I>/JN2=J+++\::JNK.)Y+\\K++kNk))V.:z6I>/JN2=J+++\::JN=K.)Y+\\K++kNk))V.:z5I>/JN2=J+++\::JN=K.)Y+\\K++kNk))V.:z4I>/JN3=J+++\::JN=K.)Y+\\K++kNk))V.:z3I>/JN4=J+++\::JN=K.)Y+\\K++kNk))V.:z2I>/JN7=J+++\::JN=K.)Y+\\K++kNk))?qeJkPJJ
```
[Test Suite Available Online](http://pyth.herokuapp.com/?code=%3DkNJ%2B%2BkzkV92Iq%2FzC%2B32N0+aYC%2B32N%29%29V.%3Az7I%3E%2FJN2%3DJ%2B%2B%2B%5C%3A%3AJNK.%29Y%2B%5C%5CK%2B%2BkNk%29%29V.%3Az6I%3E%2FJN2%3DJ%2B%2B%2B%5C%3A%3AJN%3DK.%29Y%2B%5C%5CK%2B%2BkNk%29%29V.%3Az5I%3E%2FJN2%3DJ%2B%2B%2B%5C%3A%3AJN%3DK.%29Y%2B%5C%5CK%2B%2BkNk%29%29V.%3Az4I%3E%2FJN3%3DJ%2B%2B%2B%5C%3A%3AJN%3DK.%29Y%2B%5C%5CK%2B%2BkNk%29%29V.%3Az3I%3E%2FJN4%3DJ%2B%2B%2B%5C%3A%3AJN%3DK.%29Y%2B%5C%5CK%2B%2BkNk%29%29V.%3Az2I%3E%2FJN7%3DJ%2B%2B%2B%5C%3A%3AJN%3DK.%29Y%2B%5C%5CK%2B%2BkNk%29%29%3FqeJkPJJ&input=WASHINGTON+%E2%80%94+Travelers+were+stranded+around+the+world%2C+protests+escalated+in+the+United+States+and+anxiety+rose+within+President+Trump%E2%80%99s+party+on+Sunday+as+his+order+closing+the+nation+to+refugees+and+people+from+certain+predominantly+Muslim+countries+provoked+a+crisis+just+days+into+his+administration.&test_suite=1&test_suite_input=WASHINGTON+%E2%80%94+President+Trump+on+Tuesday+nominated+Judge+Neil+M.+Gorsuch+to+the+Supreme+Court%2C+elevating+a+conservative+in+the+mold+of+Justice+Antonin+Scalia+to+succeed+the+late+jurist+and+touching+off+a+brutal%2C+partisan+showdown+at+the+start+of+his+presidency+over+the+ideological+bent+of+the+nation%E2%80%99s+highest+court.%0AWASHINGTON+%E2%80%94+President+Trump+fired+his+acting+attorney+general+on+Monday+night%2C+removing+her+as+the+nation%E2%80%99s+top+law+enforcement+officer+after+she+defiantly+refused+to+defend+his+executive+order+closing+the+nation%E2%80%99s+borders+to+refugees+and+people+from+predominantly+Muslim+countries.%0AWASHINGTON+%E2%80%94+Travelers+were+stranded+around+the+world%2C+protests+escalated+in+the+United+States+and+anxiety+rose+within+President+Trump%E2%80%99s+party+on+Sunday+as+his+order+closing+the+nation+to+refugees+and+people+from+certain+predominantly+Muslim+countries+provoked+a+crisis+just+days+into+his+administration.&debug=0)
[Generated Programs from Test Suite](http://pyth.herokuapp.com/?code=%3A%22WASHINGTON+%E2%80%94+President+Trump+on+Tuesday+nominated+Judge+Neil+M.+Gorsuch+to%7BSupreme+Court%2C+elevating+a+conservative+in%7Bmold+of+Justice+Antonin+Scalia+to+succeed%7Blate+jurist+and+touching+off+a+brutal%2C+partisan+showdown+at%7Bstart+of+his+presidency+over%7Bideological+bent+of%7Bnation%E2%80%99s+highest+court.%22%5C%7B%22+the+%22%0A%22WASHINGTON+%E2%80%94+President+Trump+fired+his+acting+attorney+general+on+Monday+night%2C+removing+her+as+the+nation%E2%80%99s+top+law+enforcement+officer+after+she+defiantly+refused+to+defend+his+executive+order+closing+the+nation%E2%80%99s+borders+to+refugees+and+people+from+predominantly+Muslim+countries.%22%0A%3A%3A%22WASHINGTON+%E2%80%94+Travelerzwere+stranded+around%7Bworld%2C+protestzescalated+in%7BUnited+Statezand+anxiety+rose+within+President+Trump%E2%80%99zparty+on+Sunday+azhizorder+closing%7Bnation+to+refugeezand+people+from+certain+predominantly+Muslim+countriezprovoked+a+crisizjust+dayzinto+hizadministration.%22%5C%7B%22+the+%22%5Cz%22s+&debug=0)
## Explanation
This program no longer abuses the fact that the article will be the first paragraph of a NY Times article and is now a general compressor of short strings. There are still some assumptions being made here, specifically that not all characters will appear in the text and that the text is at least seven characters long.
The high level explanation is that the program searches thorough the text for progressively shorter repeated strings, then replaces each repeated with a character not present in the text. Each string length has its own break even point where making a substitution is actually shorter than leaving the text alone. For strings of length 7 only 2 occurrences are needed but for strings of length 3 the break even point is 4 occurrences.
### Main Program
The main program mostly consists of six loops: one each for strings of length seven down through strings of length 2. Each loop goes over all substrings of the input with that length, counts how often they appear in the article and determines if a replacement should be made. If a replacement is made then the string is wrapped with a replacement method to obtain the original string.
This breakdown is itself broken down into several parts for readability. This first part is setting up for the main loops.
```
=kNJ++kzkV95Iq/zC+32N0 aYC+32N))
N N is initialized to " (the double quote character)
=kN assign " to k
z z is initialized to the input
++kzk wrap z with double quotes
J and assign that to J (J automatically assigns on first use)
92 +32 +32 32-126 is the "printable" character range
92 +32 +32 | causes issues so we stop before it (code point 124)
V92 ) for each printable character:
/zC+32N count occurrences of it in the input
Iq 0 ) if there are 0 occurrences:
aYC+32N append that character to list Y (Y is initialized to an empty list)
```
The six main loops are nearly identical. I will breakdown a general loop for the sake of simplicity.
```
V.:z5I>/JN2=J+++\::JN=K.)Y+\\K++kNk))
z z is the input
.:z5 get each substring of a certain length (here 5)
V ) for each string:
/JN count how many times it appears in the input
I> 2 ) if count > break even point: (here 2)
.)Y pop a character off Y (unused characters list)
=K assign it to K (K automatically assigns the first time but must be manually assigned after that)
:JN K regex replacement:
J in the input
N replace current string
K with popped character
+\: prepend : (the colon character)
+ +\\K append \ and popped character
+ ++kNk append current string wrapped in double quotes
=J and assign to variable J
```
This last section only saves one byte on the generated program but also ensures that the worst case is as long as our trivial answer.
```
?qeJkPJJ
k k is still set to " (the double quote character)
J JJ J is the string to be returned
?qeJk if the last character of J is ":
PJ return J without the last character
else:
J return J
```
### Generated Program
If no substitutions are made the generated program will be in this format:
```
"(input)
```
This will have a length of `length(input) + 1` bytes. This is the worst case, and I fear it may also be the average case. One paragraph does not have a lot of repeated strings, especially because professional writers try to vary their words.
If one substitution is made then the generated program will be in this format:
```
:"(input with replacements)"\(unused character)"(replacement string)
```
In Pyth, this is the format for replacement with regular expressions. Instances of the unused character in the input are replaced with the replacement string.
This adds a static 6 characters to the string, but in the worst case we are hitting the break even point mentioned earlier.
Here is the format for a generated program with two replacements:
```
::"(input with replacements)"\(char 1)"(str 1)"\(char 2)"(str 2)
```
As replacements stack up we simply add another colon to the front and add the substring and replacement character to the end.
I have not determined what the size reduction is in the best case. If anyone can determine the size of the generated program in the best case please let me know.
[Answer]
# [Retina](https://github.com/m-ender/retina), worst case (3+original length) bytes
*EDIT: added support for newlines, in order to try this code in actual kolmogorov complexity challenges. Behaviour on strings without newlines remains unchanged.*
Retina is great at substituting substrings, so that's what we're going to do!
This program looks for repeated sequences of characters and replaces them every time with a single character not appearing in the full string. The generated program then starts with the "compressed" string and applies all substitutions in reverse.
This code adds 3 bytes of boilerplate (a newline at the beginning, and a `\`` towards the end to suppress a trailing newline), so in the worst case (when there are no repeated sequences worth substituting) we have a length of 3 bytes more than the starting string. On average, this will shave a few bytes from the original length, not much but still a compression.
Here's the code with some comments:
First, we use a trick with transliteration ranges to change newlines into `¶`, which is how newlines are printed in a Retina program
```
T`µ¶·`µ-·
```
then we start the main loop, duplicating the first line
```
{`^.+
$&¶$&
```
we only substitute when the sequence is repeated enough times (depending on its length)
```
^.*?((......+).*?\2|(.....?).*?\3.*?\3|(...).*?\4.*?\4.*?\4|(..).*?\5.*?\5.*?\5.*?\5.*?\5).*
"$2$3$4$5
^"(.+)|^.*
$+
```
to find a character not in the string, we append a list of candidates to the string, using `"` as separator, and then remove duplicates
```
^(.*)¶(.*)
$2" 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#%&\'()*+,-./:;?@\^_`{|}~¶$2¶$1
D`(?<=^.*).
^.*"(.)?.*¶(.+)
$2¶$1
```
here the actual substitution in the text happens
```
+`^(.*)(.+)(.*¶(.)¶\2(¶|$))
$1$4$3
```
in case we couldn't find a repeated sequence or an unused character, we restore the string to the original state (which makes us break from the loop)
```
}`(.*)¶(¶.*|.*¶)(¶|$)
$1$3
```
at the end, we add the 3 bytes of boilerplate
```
^
¶
\-1=`.*¶
\`$&
```
[Try it online!](https://tio.run/nexus/retina#bVHtcpNAFP2/T3GNGCEkaEjidyeN1jZVm1YbjToMQuACqwTiLiTFpo4P4atI//MovkjcJc74x53hLvecM/ecO7udOtWvqqyuxdWprsmlYxs6UZpVqTSJbbSGqmrUR9dEY5mbXTusu15daqju@/@KBGts8L8iGNJQTKWn9JUBsRuqGL8RbkTRia0aLa0qZSWK2YC7XbPXH9y7/@ChO/d8DMKIfv4SL5J0@ZXxLF@tL4pvo6fPDp4fHo2PX7x8dTI5PXv95nz69t3s/YePN27ealq3Va2ltzvGnUePh/uW/cm53Fx9Fxua4uuSA0cdPtkT7pohNxZhtKHRkgl0maDW6E4dS0LqjhMRLVOtyo2iCVVXLNIjV87f7FVptDZSp@0UUtAjNqlKYnW6e46kiOUoze12NjofH0@OpqcT@P3jJ4w4nDHk1MckgynLF0vgNEzQBxf4GnFJkxDwAr08oyuElPnIIE3gkFHfLdrAozzLpCaLEOY1zSFLgWGQh4gc3MSHVJACDli6AI4rTCB2WYhxASc5j@kCvDRPMkaRt@s5HD2GmcsKSAOI0gXGcopAc0azAtYulxFcmEU0QxinOUcxIgmQYeKJXzeOIcRdrogKYypeDoJcwHPhEkhcDJBWYZzO3VisQYMMaALLNKZeYfwB "Retina – TIO Nexus")
In the linked example, the 292 bytes paragraph gets compressed to a 286 bytes Retina code.
NOTE: the substitutions made are not optimal, we just make every time the first suitable substitution we find; I don't know if an algorithm finding the optimal substitutions could run in a reasonable amount of time.
[Answer]
## CJam, range reduction and base conversion
I think it's stupid to ban builtins for base-conversion as "compression", but I've implemented my own.
```
q
e# Reduce range by offsetting towards 0 as far as possible
:i_:e<:If-
e# Base-convert to the minimal possible base
_:e>):B;W%{\B*+}*
e# Base-convert to base 256
[{256md\}h;]W%
e# Format as a string literal with as few special cases as possible
:c'"\'"/"\\\""*'"
e# Decoder base-converts to base 256 and then base B, adding the offset
":i{\256*+}*{"B"md"I"c+\}h;"
```
The text is too small to benefit greatly from techniques which require a lot of decoding, but if we can subtract 32 from each byte and base-convert then we get an asymptotic improvement of at least 2.4%, and with luck the input source will be pure ASCII and we get an asymptotic improvement of about 18.7%. With an overhead of about 26 bytes we stand a decent chance of getting compression.
If the output is allowed to have a trailing NUL byte, one byte can be saved by removing that final `;`.
[Answer]
# Pyth, `length(input) + 1` bytes
```
+Nz
```
[Online interpreter available here.](http://pyth.herokuapp.com/?code=%2BNz&input=Lorem+ipsum+dolor+sit+amet%2C+consectetur+adipiscing+elit%2C+sed+do+eiusmod+tempor+incididunt+ut+labore+et+dolore+magna+aliqua.+Ut+enim+ad+minim+veniam%2C+quis+nostrud+exercitation+ullamco+laboris+nisi+ut+aliquip+ex+ea+commodo+consequat.+Duis+aute+irure+dolor+in+reprehenderit+in+voluptate+velit+esse+cillum+dolore+eu+fugiat+nulla+pariatur.+Excepteur+sint+occaecat+cupidatat+non+proident%2C+sunt+in+culpa+qui+officia+deserunt+mollit+anim+id+est+laborum.&debug=0)
This will return a generated program of the form `"(input)`. Put another way, the main program prepends a double quote to the input text.
## Main Program Explanation
```
+ Concatenate
N " (the variable N defaults to a double quote mark)
z and the input
```
## Generated Program Explanation
```
" start of a string
(input) the input text
(eof) strings are closed automatically at the end of file
```
This is the shortest of the "input length plus a constant" answers. I'm posting this mostly to set a bar for the non-trivial answers. It's unclear if a non-trivial answer can exist within the rules as they are currently worded, but I am setting this bar nonetheless.
[Answer]
# C++11, arithmetic coding, overhead >= 382 bytes
Compression algorithm is shamelessly copied from [Simple byte-aligned binary arithmetic coder by Fabian 'ryg' Giesen](https://github.com/rygorous/mini_arith/blob/master/main.cpp "Simple byte-aligned binary arithmetic coder by Fabian 'ryg' Giesen")
```
#include <iostream>
using std::cout;
void pu(char c){c=='\r'?cout.write(")OMG\" \"\\r\" R\"OMG(",17):cout.put(c);}
int main() {
uint32_t lo{0},hi{~0u},x,i,prob{256};
char ch;
cout<<R"!*(#include <iostream>
void operator ""_p(const char* q,size_t z){uint32_t d{0},l{0},h{~0u},p{256},x,t;size_t r{0},i;for(i=4;i-->0;)d=(d<<8)|q[r++];while(r<=z){char y{0};for(i=8;i-->0;){x=l+((uint64_t(h-l)*p)>>9);t=(d<=x);t?(h=x):(l=x+1);while((l^h)<(1u<<24)){d=(d<<8)|q[r++];l<<=8;h=(h<<8)|0xff;}p+=t?((512-p)>>5):-(p>>5);y+=y+t;}std::cout.put(y);}}int main(){R"OMG()!*";
while (std::cin.get(ch)) {
for (size_t b=8; b-->0;) {
int bit{ch&(1<<b)};
x = lo+((uint64_t(hi-lo)*prob)>>9);
bit ? (hi=x) : (lo=x+1);
while ((lo^hi)<(1u<<24)) {pu(lo>>24);lo<<=8;hi=(hi<<8)|0xff;}
prob += bit?((512-prob)>>5):-(prob>>5);
}
}
for (i=4;i-->0;) {pu(lo>>24);lo<<=8;}
cout<<")OMG\"_p;return 0;}";
return 0;
}
```
## Explanation
1. Main program reads the input and uses BinShiftModel to generate an encoded bitstream.
2. The bitstream is then included into a C++11 user-defined raw literal in the output program.
3. The literal is being processed by the user-defined function, `operator ""_p(const char* string, size_t size)`, printing out the decoded stream.
Some extra care was necessary due to all newline values being converted to `\n`.
## Improvement
The code does not look for different compression paths (there were, but some optimal value was chosen instead).
It is possible to improve the compression ratio, either by limiting input to 7 bits (did not do that because "em-dash" in the sample became corrupted) or by storing MSB from all input bytes first, which will likely be roughly same for 1/4 of the text.
Either way, algorithm overhead is huge on small texts.
## Usage
`g++ -std=c++11 -o golf golf.cpp && ./golf < sample.txt > degolf.cpp && g++ -std=c++11 -o degolf degolf.cpp && ./degolf`
[Answer]
## Lua
```
print('print"'..io.read()..'"')
```
[Try it here](http://ideone.com/I1PBgi).
Will always be `string length + 7` bytes long.
## C#
```
using System;
namespace H {
class K {
static string P;
static void Main(string text)
{
P = text;
Console.WriteLine("()=>{Console.WriteLine(H.K.P);}");
}
}
}
```
Works if the program itself is added as a dependency where you run the resulting output program. If you would to run the resulting code in a `OutputText.exe`, you will have to add `OutputCodeThatOutputsText.exe` as a dependency.
Resulting code is always `()=>{Console.WriteLine(H.K.P)}`.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This question does not appear to be about code golf or coding challenges within the scope defined in the [help center](https://codegolf.stackexchange.com/help/on-topic).
Closed 7 years ago.
[Improve this question](/posts/24504/edit)
Prove anti-virus software is paranoid by making a program that simply opens and alphabetically sorts a CSV file, that will get flagged as a virus (or malware/spyware/any threat really) when run.
You will be assessed by the following criteria:
* Does the cross-platform anti-virus package ClamAV detect it as a threat?
* Your code is not actually a virus (if the code looks fishy it will be deducted points)
* Conciseness of code
The specific target for this challenge is the following version of ClamAV with the following virus definitions (current as of the posting of this challenge). Your program must trigger this set of software/definitions to be eligible.
You may wish to use a virtual machine for testing your code.
```
Latest ClamAV® stable release is: 0.98.1
ClamAV Virus Databases:
main.cvd ver. 55 released on 17 Sep 2013 10:57 :0400 (sig count: 2424225)
daily.cvd ver. 18639 released on 19 Mar 2014 06:45 :0400 (sig count: 839186)
bytecode.cvd ver. 236 released on 05 Feb 2014 12:36 :0500 (sig count: 43)
safebrowsing.cvd ver. 41695 released on 19 Mar 2014 03:00 :0400 (sig count: 1147457)
```
[Answer]
# bash (113)
```
sort -t, "$1"
#PK^C^D^@^@^@^@^@^@^@^@^@^@^@^@^@^@D^@^@^@D^@^@^@^@^@^@^@X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*
```
The above uses [caret notation](https://en.wikipedia.org/wiki/Caret_notation). Notably, `^@` indicates a null byte.
### How it works
* `sort -t, "$1"` sorts the file specified as the first command-line argument (`$1`), using the comma character as field delimiter (`-t,`).
* `#` at the beginning of the second line comments it out; it will get ignored by bash.
* `PK^C^D^@^@^@^@^@^@^@^@^@^@^@^@^@^@D^@^@^@D^@^@^@^@^@^@^@` is the shortest possible [*ZIP file local file header*](https://www.pkware.com/documents/APPNOTE/APPNOTE-1.0.txt):
+ `PK^C^D` (0x04034B50) is the *local file header signature*.
+ `^@^@^@^@^@^@^@^@^@^@^@^@^@^@` specifies the ZIP version, a bit flag, the compression method and the compressed file's mtime and checksum. All are set to zero.
+ The twice occurring `D^@^@^@` (0x00000044 or 68) specifies the file's compressed and uncompressed length (68 bytes).
+ `^@^@^@^@` specifies the filename and extra header length. Both are set to zero.
* `X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*` is the 68 byte long [EICAR test string](https://en.wikipedia.org/wiki/EICAR_test_file), which serves as the data associated to the above header.
This takes advantage of the fact that ClamAV will act on all *ZIP file local file headers*, even if they're encountered outside of actual ZIP files.
### Malware scan
[VirusTotal](https://www.virustotal.com/en/file/71fcbebf3679bb5c0f61896e0042ae1f9400ad2a0c66eb0d32ef5643e6aa8015/analysis/1395329382/) gives 15 false positives out of its current 51 scanners. This includes ClamAV.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/19225/edit).
Closed 7 years ago.
[Improve this question](/posts/19225/edit)
The biggest program that reads a single line (terminated by your choice from NULL/CR/LF/CRLF) from stdin, reverses it, then prints it to stdout.
No redundant code [code which could safely be deleted] such as
```
return ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
```
or redundant data that's used to stop code being redundant:
```
char* data = <kernel source code>;
if (md5sum(data) != <hash>) {
return 1; //Fail for no good reason because it lets us add 1000000 lines of data
}
```
Basically, the largest implementation of a string reverse, with no *obvious* attempt to game the question.
[edit]
I am tempted to say that the code must be finite for unbounded input length, but there have been some clever and interesting O(>1) length solutions. I instead ask that people avoid posting simple brute-force lookup-list solutions as separate answers (comments are fine!).
[Answer]
## C# – Something about 90 KB, but actually, ~90×*n* for any *n*
See <https://gist.github.com/mormegil-cz/8581459> for the full source code. A short preview version to taste:
```
var c1 = Console.Read();
if (c1 > 0 && c1 != 13)
{
var c2 = Console.Read();
if (c2 > 0 && c2 != 13)
{
var c3 = Console.Read();
if (c3 > 0 && c3 != 13)
{
// ...
Console.Write((char)c3);
}
Console.Write((char)c2);
}
Console.Write((char)c1);
}
Console.WriteLine();
```
And because writing the source code seems a bit repetitive, let’s use a simple tool:
```
void Main()
{
const int MAX_DEPTH = 1000;
Console.WriteLine("using System;");
Console.WriteLine("using System.Text;");
Console.WriteLine();
Console.WriteLine("class C");
Console.WriteLine("{");
Console.WriteLine("\tstatic void Main()");
Console.WriteLine("\t{");
for (int i = 0; i < MAX_DEPTH; ++i)
{
var indent = new string('\t', i + 2);
Console.WriteLine("{0}var c{1} = Console.Read();", indent, i);
Console.WriteLine("{0}if (c{1} > 0 && c{1} != 13)", indent, i);
Console.WriteLine("{0}{{", indent);
}
var restIndent = new string('\t', MAX_DEPTH + 2);
Console.WriteLine("{0}var rest = new StringBuilder();", restIndent);
Console.WriteLine("{0}for (var c = Console.Read(); c > 0 && c != 13; c = Console.Read())", restIndent);
Console.WriteLine("{0}{{", restIndent);
Console.WriteLine("{0}\trest.Append((char)c);", restIndent);
Console.WriteLine("{0}}}", restIndent);
Console.WriteLine("{0}var restArray = rest.ToString().ToCharArray();", restIndent);
Console.WriteLine("{0}Array.Reverse(restArray);", restIndent);
Console.WriteLine("{0}Console.Write(new string(restArray));", restIndent);
for (int i = MAX_DEPTH - 1; i >= 0; --i)
{
var indent = new string('\t', i + 2);
Console.WriteLine("{0}\tConsole.Write((char)c{1});", indent, i);
Console.WriteLine("{0}}}", indent);
}
Console.WriteLine("\t\tConsole.WriteLine();");
Console.WriteLine("\t}");
Console.WriteLine("}");
}
```
Change `MAX_DEPTH` to get a larger score (or possibly an internal C# compiler error?).
[Answer]
## C#
**6710 bytes**
**212 lines of code** including 6 comments
**3 classes, 2 interfaces, 1 file**
```
using System;
using System.Collections.Generic;
namespace StringReverse
{
public class Program
{
public static void Main(string[] args)
{
UnreversedString unreversed = Console.ReadLine();
ReversedString reversed = ReverseString(unreversed);
Console.WriteLine(reversed);
}
public static ReversedString ReverseString(UnreversedString unreversed)
{
// We know that string reversing is recursive.
// We also know that recursion is confusing.
// Therefore, we will use a recursive algorithm without actually using recursion.
// This will greatly "simplify" our code. ;)
Stack<IString> stringStack = new Stack<IString>();
stringStack.Push(unreversed);
Random random = new Random();
do
{
if (stringStack.Peek() is UnreversedString)
{
IString unreversedString = stringStack.Pop();
if (unreversedString.Length < 2)
{
ReversedString reversedString = unreversedString.ToString();
stringStack.Push(reversedString);
}
else
{
int randomInt = random.Next(unreversedString.Length);
IString firstHalfOfUnreversedString = unreversedString.Substring(0, randomInt);
IString secondHalfOfUnreversedString = unreversedString.Substring(randomInt);
stringStack.Push(firstHalfOfUnreversedString);
stringStack.Push(secondHalfOfUnreversedString);
}
}
else
{
IString firstString = stringStack.Pop();
IString secondString = stringStack.Pop();
if (secondString is UnreversedString)
{
stringStack.Push(firstString);
stringStack.Push(secondString);
}
else
{
ReversedString newReversedString = secondString.ToString() + firstString.ToString();
stringStack.Push(newReversedString);
}
}
}
while (stringStack.Count > 1);
return stringStack.Pop() as ReversedString;
}
}
// We need a common way to treat strings, because they all need to be stored in the same stack.
public interface IString
{
int Length
{
get;
}
IString Substring(int startIndex);
IString Substring(int startIndex, int length);
}
public interface IString<T> : IString where T : IString<T>
{
new T Substring(int startIndex);
new T Substring(int startIndex, int length);
}
// We also need a way to differentiate between them.
public class UnreversedString : IString<UnreversedString>
{
private string unreversedString;
public string UnreversedStringValue
{
get
{
return this.unreversedString;
}
set
{
this.unreversedString = value;
}
}
public int Length
{
get
{
string unreversedString = this;
return unreversedString.Length;
}
}
public UnreversedString Substring(int startIndex)
{
string unreversedString = this;
return unreversedString.Substring(startIndex);
}
public UnreversedString Substring(int startIndex, int length)
{
string unreversedString = this;
return unreversedString.Substring(startIndex, length);
}
IString IString.Substring(int startIndex)
{
return this.Substring(startIndex);
}
IString IString.Substring(int startIndex, int length)
{
return this.Substring(startIndex, length);
}
public override string ToString()
{
return this.UnreversedStringValue;
}
public static implicit operator string(UnreversedString unreversedString)
{
return unreversedString.ToString();
}
public static implicit operator UnreversedString(string unreversedString)
{
UnreversedString newUnreversedString = new UnreversedString();
newUnreversedString.UnreversedStringValue = unreversedString;
return newUnreversedString;
}
}
public class ReversedString : IString<ReversedString>
{
private string reversedString;
public string ReversedStringValue
{
get
{
return this.reversedString;
}
set
{
this.reversedString = value;
}
}
public int Length
{
get
{
string reversedString = this;
return reversedString.Length;
}
}
public ReversedString Substring(int startIndex)
{
string reversedString = this;
return reversedString.Substring(startIndex);
}
public ReversedString Substring(int startIndex, int length)
{
string reversedString = this;
return reversedString.Substring(startIndex, length);
}
IString IString.Substring(int startIndex)
{
return this.Substring(startIndex);
}
IString IString.Substring(int startIndex, int length)
{
return this.Substring(startIndex, length);
}
public override string ToString()
{
return this.ReversedStringValue;
}
public static implicit operator string(ReversedString reversedString)
{
return reversedString.ToString();
}
public static implicit operator ReversedString(string reversedString)
{
ReversedString newReversedString = new ReversedString();
newReversedString.ReversedStringValue = reversedString;
return newReversedString;
}
}
}
```
[Answer]
# [Mornington Crescent](https://github.com/padarom/esoterpret), ~~1480~~ 1587 bytes
+107 bytes thanks to Cloudy7
```
Take Northern Line to Moorgate
Take Metropolitan Line to Moorgate
Take Metropolitan Line to Wembley Park
Take Metropolitan Line to Wembley Park
Take Jubilee Line to West Ham
Take Hammersmith & City Line to West Ham
Take Hammersmith & City Line to Euston Square
Take Hammersmith & City Line to Euston Square
Take Circle Line to Liverpool Street
Take Central Line to Liverpool Street
Take Central Line to Oxford Circus
Take Victoria Line to Oxford Circus
Take Victoria Line to Victoria
Take Victoria Line to Victoria
Take District Line to Bank
Take Waterloo & City Line to Bank
Take Waterloo & City Line to Waterloo
Take Waterloo & City Line to Waterloo
Take Bakerloo Line to Piccadilly Circus
Take Piccadilly Line to Piccadilly Circus
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Piccadilly Circus
Take Piccadilly Line to Piccadilly Circus
Take Bakerloo Line to Waterloo
Take Waterloo & City Line to Waterloo
Take Waterloo & City Line to Bank
Take Waterloo & City Line to Bank
Take District Line to Victoria
Take District Line to Victoria
Take Victoria Line to Oxford Circus
Take Victoria Line to Oxford Circus
Take Central Line to Liverpool Street
Take Central Line to Liverpool Street
Take Circle Line to Euston Square
Take Hammersmith & City Line to Euston Square
Take Hammersmith & City Line to West Ham
Take Hammersmith & City Line to West Ham
Take Jubilee Line to Wembley Park
Take Metropolitan Line to Wembley Park
Take Metropolitan Line to Moorgate
Take Metropolitan Line to Moorgate
Take Northern Line to Mornington Crescent
```
This code goes around in a huge loop using every single line but the Piccadilly Line, ending in Piccadilly Circus. Then it goes to Turnpike Lane, which reverses the string, before finally unwinding the loop and returning to Mornington Crescent.
[Try it online!](https://tio.run/##rZXNbsIwDMfve4qcdttLwCZNU9mQQOOcBg8s0rg47kSfnkWFAl03dUl3iSL/f1Li74LYodsIuQfD4A04OR6XegfqlVi2wE5l6EAJqRkRb7TAXSPPQJhKsig6CllBkVuo1VzzLgp7qXK0ADeEF/Wsi5MaLgWwL1C26l5NUep48KnyIQ5qsa80Qwo9RTb2@sMMP4FLIqsWwgByhkKIWdtI6u3wQbxuXqj8CXlHI8Soo5jW8Cf5Eb1wsFzkiXbnbKxCltkSfY/KMNHaY6hJOBqqledojF6jtXXH3RtzPLms2JUYtEw7GEmN/l/P45SwpSfpSvRqYKBEBgossY7TmuYXqtulo7v@P0ZPF@yPusSZmTqku8gPm6BdGmp6WRo6P3wB "Mornington Crescent – Try It Online")
[Answer]
**Windows Command Script - 101 + 76\*361 + 78\*362 + ... + 276\*36100 bytes**
*Note: max string length is 100, and the string is limited to alphanumeric characters*
```
@echo off
echo.Enter string to reverse
set /p i=:
call :%i%
cscript //nologo rev.js
pause&exit/b
:a
echo.WScript.Echo("a".split("").reverse().join(""));>rev.js
exit /b
:aa
echo.WScript.Echo("aa".split("").reverse().join(""));>rev.js
exit /b
:aaa
.... and so on
```
Generated by:
```
@echo off
echo.Generating code... (this will take a LOOOONG time)
echo>b.cmd @echo off
echo>>b.cmd echo.Enter string to reverse
echo>>b.cmd set /p i=:
echo>>b.cmd call :%%i%%
echo>>b.cmd cscript //nologo rev.js
echo>>b.cmd pause^&exit/b
goto b
:a
echo>>b.cmd :%1
echo>>b.cmd echo.WScript.Echo("%1".split("").reverse().join(""));^>rev.js
echo>>b.cmd exit /b 1
set tmp=%1
if not "%tmp:~100,1%"=="" (
exit /b 0
)
:b
for %%a in (a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9) do call :a %1%%%a
```
Have fun waiting...
[Answer]
# Brainfuck: 72 bytes
```
>>+[-<,[+[-----------[---[+++++++++++++>>+<]]]]>]<<[.[-]<]++++++++++.[-]
```
Suports CR/LF/CRLF no change EOF, -1 EOF and 0 EOF to get the bytecount up so it's very compatible.
Getting it larger is puishing it since BF is such a compact language. It's really better for golfing :-p
[Answer]
You may find this answer a rule-bending one, you'll decide whether it's valid or not.
This code:
* Is self-commented;
* Handles every string from STDIN and outputs it in STDOUT;
* Handles IO exceptions;
* Has very bad memory usage;
* Is very unefficient;
* Will eventually end...
This answer is between the code-trolling and the code-bowling: it is trolling the user that reads/uses/wrote that code (am I trolling myself?), but it actually works; could be much shorter, but there is no redundant code (if you delete even one of the lines or the commands, it won't work). Also, it won't seem (at least, didn't to me) it is attempting to game the question.
# C# - 6.825 7.037 bytes
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
namespace Console
{
class Program
{
private const string omgAreYouDumbYouHaveToUseThisProgramThisWay = "Oh gawd please type the command this way! programName inputfile.txt outputfile.txt";
static int Main(string[] sgra)
{
StreamWriter initializeThisStreamWriterHereBecauseItsCool = null;
StreamReader initializeThisStreamReaderHereBecauseItsEvenCooler = null;
if (sgra.Length < (calculateIntegerToAdd()+calculateIntegerToAdd()))
{
int didYouNoticeThatSgraIsArgsBackwardsAhahImSoFunny = calculateIntegerToAdd();
WriteThisLineHereAndNowDidYouHearMeh(omgAreYouDumbYouHaveToUseThisProgramThisWay);
return didYouNoticeThatSgraIsArgsBackwardsAhahImSoFunny;
}
try
{
initializeThisStreamWriterHereBecauseItsCool = new StreamWriter(sgra[calculateIntegerToAdd()]);
initializeThisStreamReaderHereBecauseItsEvenCooler = new StreamReader(sgra[calculateIntegerToAdd()-calculateIntegerToAdd()]);
System.Console.SetOut(initializeThisStreamWriterHereBecauseItsCool);
System.Console.SetIn(initializeThisStreamReaderHereBecauseItsEvenCooler);
}
catch (IOException thisExceptionWouldMakeMyProgramCrashButICatchedItHaha)
{
TextWriter thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz = System.Console.Error;
int valueThatWillBeReturnedBecauseThereIsAnErrorWowItsSoBad = calculateIntegerToAdd();
thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz.WriteLine(thisExceptionWouldMakeMyProgramCrashButICatchedItHaha.Message);
thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz.WriteLine(omgAreYouDumbYouHaveToUseThisProgramThisWay);
thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz.Close();
return valueThatWillBeReturnedBecauseThereIsAnErrorWowItsSoBad;
}
string thisIsGoingToBeReversedButHowPleaseTellMe = WootAreYouDoingDontMessAroundAndReadThatLine();
char[] imGoingToStoreAllCharactersHereBecauseItsFun = new char[thisIsGoingToBeReversedButHowPleaseTellMe.Length];
for (int awfulCounterWhyAreYouHere = calculateIntegerToAdd()-calculateIntegerToAdd(); awfulCounterWhyAreYouHere < thisIsGoingToBeReversedButHowPleaseTellMe.Length; awfulCounterWhyAreYouHere++)
{
imGoingToStoreAllCharactersHereBecauseItsFun[awfulCounterWhyAreYouHere] = thisIsGoingToBeReversedButHowPleaseTellMe.ElementAt(awfulCounterWhyAreYouHere);
}
char[] thisIsTheSolutionIllCheckIfMineIsEqual = new char[imGoingToStoreAllCharactersHereBecauseItsFun.Length];
int pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome = thisIsGoingToBeReversedButHowPleaseTellMe.Length-thisIsGoingToBeReversedButHowPleaseTellMe.Length;
for (int awfulReversedCounterWhyAreYouHere = imGoingToStoreAllCharactersHereBecauseItsFun.Length-calculateIntegerToAdd();awfulReversedCounterWhyAreYouHere>-calculateIntegerToAdd();awfulReversedCounterWhyAreYouHere--)
{
thisIsTheSolutionIllCheckIfMineIsEqual[pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome] = imGoingToStoreAllCharactersHereBecauseItsFun[awfulReversedCounterWhyAreYouHere];
pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome = pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome + calculateIntegerToAdd();
}
int cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient = pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome-pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome;
while (new String(imGoingToStoreAllCharactersHereBecauseItsFun) != new String(thisIsTheSolutionIllCheckIfMineIsEqual))
{
imGoingToStoreAllCharactersHereBecauseItsFun = bogoSortCanSu_Ehm_CannotBeatMyAlgorythmsAwesomeness(imGoingToStoreAllCharactersHereBecauseItsFun);
cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient = cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient + calculateIntegerToAdd();
}
string omgIHaveASolutionHowLongDidItTake = new String(imGoingToStoreAllCharactersHereBecauseItsFun);
WriteThisLineHereAndNowDidYouHearMeh(omgIHaveASolutionHowLongDidItTake);
initializeThisStreamWriterHereBecauseItsCool.Close();
return cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient;
}
public static char[] bogoSortCanSu_Ehm_CannotBeatMyAlgorythmsAwesomeness(char[] uselessVariableWhichIsGoingToBeUsedAsInput)
{
char[] uselessVariableWhichIsGoingTobeReturned = uselessVariableWhichIsGoingToBeUsedAsInput;
Random thisWillDecideWhichIndexesAreGoingToBeSwapped = new Random();
int firstIndexToBeSwappedRandomlyGenerated = thisWillDecideWhichIndexesAreGoingToBeSwapped.Next(uselessVariableWhichIsGoingTobeReturned.Length);
int secondIndexToBeSwappedRandomlyGenerated = thisWillDecideWhichIndexesAreGoingToBeSwapped.Next(uselessVariableWhichIsGoingTobeReturned.Length);
char tempVariableWhichWillBeUsedForSwap = uselessVariableWhichIsGoingTobeReturned[firstIndexToBeSwappedRandomlyGenerated];
uselessVariableWhichIsGoingTobeReturned[firstIndexToBeSwappedRandomlyGenerated] = uselessVariableWhichIsGoingTobeReturned[secondIndexToBeSwappedRandomlyGenerated];
uselessVariableWhichIsGoingTobeReturned[secondIndexToBeSwappedRandomlyGenerated] = tempVariableWhichWillBeUsedForSwap;
return uselessVariableWhichIsGoingTobeReturned;
}
public static void WriteThisLineHereAndNowDidYouHearMeh(string stringToBeWrittenHereAndNow)
{
System.Console.WriteLine(stringToBeWrittenHereAndNow);
}
public static string WootAreYouDoingDontMessAroundAndReadThatLine()
{
string thisStringIsGoingTobeReturnedOmgWhatDoIDoWhatDoIDo;
thisStringIsGoingTobeReturnedOmgWhatDoIDoWhatDoIDo = System.Console.ReadLine();
return thisStringIsGoingTobeReturnedOmgWhatDoIDoWhatDoIDo;
}
public static int calculateIntegerToAdd()
{
Random thisWillGenerateNumbersUntilItGetsOneItMayTakeAWhile = new Random();
int isThisIntegerEqualToOneOrNot = 0;
while (isThisIntegerEqualToOneOrNot != 1)
{
isThisIntegerEqualToOneOrNot = thisWillGenerateNumbersUntilItGetsOneItMayTakeAWhile.Next(0,10);
}
int thisIntegerIsEqualToOne = isThisIntegerEqualToOneOrNot;
return thisIntegerIsEqualToOne;
}
}
}
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/189733/edit).
Closed 4 years ago.
[Improve this question](/posts/189733/edit)
Write a program that prints an associative array (key-value) to a table.
# Requirements
* Standard loopholes are forbidden
* Please include a link to an online interpreter and the byte count in the answer
* Use [box drawing characters](https://en.wikipedia.org/wiki/Box-drawing_character) to draw the table.
* You can write both a full program or a function.
* Key or value can't contain multiline strings.
* Value/key can't be an array/associative array ( example: `["a"=>["a"=>"b"]] or ["a"=>["a","b"]]` )
## Special cases
* If the programming language lacks of associative array , you can use a list of pairs. Example: `[[key1,value1],[key2,value2]]`
* You can insert horizontal lines between successive pairs.
* An input array can't be empty
### This is a code-golf, the answer with the shortest byte count wins!
# Challenge
Your code must draw a vertical table like in the example from a associative array . The key must be at left and value must be at right and them needs to be separed,you can choose how separe them. Every key-value pair must be in another row.
There must be only 2 columns for the keys and value.
# Example
Array(PHP):
`["a"=>"b","c"=>"d","d"=>"d"]`
Output:
```
┏━━━┓
┃a┃b┃
┃c┃d┃
┃d┃d┃
┗━━━┛
```
[Answer]
# [TryAPL](https://tryapl.org), 1 [byte](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function. As TryAPL has no associative arrays, this takes a list of pairs as argument.
```
↑
```
[Try APL!](https://tryapl.org/?a=f%u2190%u2191%20%u22C4%20f%20%28%27key1%27%20%27value1%27%29%20%28%27key2%27%20%27value2%27%29&run)
`↑` mix the list of pairs into a table
[Answer]
# [J](http://jsoftware.com/), 1 byte
```
>
```
So… to take strings as input they need to be in boxes already, and to make them pairs I *think* they need to be put into a box again so that they can be treated separately. I'm not too sure about the second part.
Anyway, unboxing the whole thing gives the desired form.
I get a sense that this could be a 0 byte answer if we twist the format enough (or maybe less, since a 2d array of boxes seems to be the proper input format instead of my weird format), but I don't understand boxing all that well.
[Try it online!](https://tio.run/##y/r//39qcka@gp2Gho2htZGmjoaNsbWJpiYXXFQ9MUndWj05RR0kp56alg7kZWRmqWtq/gcA "J – Try It Online")
[Answer]
# [PHP](https://php.net/), 563 bytes
```
<?php
$t = ["a"=>"b","c"=>"d"];
$k = $v = $i = $j = 0;
foreach ($t as $a => $b){
$k = (strlen($a) > $k ? strlen($a) : $k);
$v = (strlen($b) > $v ? strlen($b) : $v);
}
echo "┏"; for(; $i++ < $k + $v + 3;) echo "━";
echo "┓\n";
foreach ($t as $a => $b){
echo "|{$a} ";
for($i = 0; $i < $k - strlen($a); $i++) echo " ";
echo "| {$b}";
for($i = 0; $i < $v - strlen($b); $i++) echo " ";
echo "|\n";
}
echo "┗"; for(; $j++ < $k + $v + 3;) echo "━";
echo "┛";
?>
```
[Try it online!](https://tio.run/##lZA7DsIwDIZ3TmFZGVoVJCQ2QtuDAENSispDpQKUpXTgBAwgMXA7LlLiBNqw8MhgJXa@379dZEVdj@IiKzqgD9tDCGMUGEYosYsJXWY45ba60lWmKCwoLHXo29J8s01FkoGnFcQOmIAwAib90lQb2Nvtt@s095jwIaJUDE5mqDM@bwnlEtIQyiGkIdSTqExMk2wDeL@ckJMnj2urQQAj6hUQHsCA@823I/I37DzJ8deBLHMomagAW9fU1aynT71t554zpXX0suCST0Eomaw@CipHUH4XbGZ6X9G1XdHyjxXd9DuO6voB "PHP – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 62 bytes
```
Ｆ²⊞υ×━⌈ＥθＬ§κι⟦⪫┏┓⪫υ┳⟧Ｅθ⪫┃┃⪫Ｅι◨λＬ§υμ┃⪫┗┛⪫υ┻
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8tv0hBw0hTIaC0OEOjVEchJDM3tVhD6dGURiUdBd/Eiszc0lwN38QCjUIdBZ/UvPSSDA3HEs@8lNQKjWwdhUxNMLDmCijKzCvRiPbKz8wDae5/NGUyUD@YCzQUKLJZSVMzFq4QaiBMeTMQwZSDpDJ1FAISU4Iy0zNKNHIw7AUamAuyFWxusxKyA2AGTn80ZTaq/btB6qz//4@OjlZKVNJRSlKK1YlWSgayUpRiY2P/65blAAA "Charcoal – Try It Online") Link is to verbose version of code. Charcoal's code page doesn't include box-drawing characters so they cost 3 bytes but the code uses them instead of their three-byte encoding because it looks nicer. Takes input as an array of tuples as Charcoal doesn't have an iterable dictionary. Explanation:
```
Ｆ²⊞υ×━⌈ＥθＬ§κι
```
Find the length of the longest key and value and repeat `━` according to that length.
```
⟦⪫┏┓⪫υ┳⟧
```
Embed the `━`s in `┏┳┓`.
```
Ｅθ⪫┃┃⪫Ｅι◨λＬ§υμ┃
```
For each tuple, pad the strings to the length of the `━`s and wrap them with `┃`s.
```
⪫┗┛⪫υ┻
```
Embed the `━`s in `┗┻┛`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~189~~ ~~172~~ ~~168~~ ~~173~~ 169 bytes
```
def f(d):t=d.items();a,b=map(lambda*l:max(map(len,l)),*t);c='─'*a,'─'*b;print("┌%s┬%s┐"%c,*[f"│{k:{a}}│{v:{b}}│"for k,v in t],"└%s┴%s┘"%c,sep="\n")
```
[Try it online!](https://tio.run/##JYsxCoMwGIWvEn4QEwldukVykrbDH5NQUaNoEIsIpXOHDg49RMeeyItYY5f3Pj7ea27@WrvjumpjiaWaCS/1Ifem6ihLkStZYUNLrJTGpBQVDnQXxvGSMZ54lmYyXuZ7nCD/t0qbNneewjI/o26ZPyFeEGU8OdlNPsZCjDhNgXoxqp3A1i0peE9yR/yFb7M53L4h3uHbmUbC2QFbLR0BEQQo4ASyDbQOhLscYGLrDw "Python 3 – Try It Online")
] |
[Question]
[
In the old DOS operating system, a number of characters were provided to draw boxes. Here is a selection of these characters and their code points:
```
B3 B4 BF C0 C1 C2 C3 C4 C5 D9 DA
│ ┤ ┐ └ ┴ ┬ ├ ─ ┼ ┘ ┌
```
You can use these characters to draw boxes like this:
```
┌─────────┐
│ │
└─────────┘
```
Boxes can be attached to each other:
```
┌───┐
│ │
┌───┬───┤ │
│ │ │ │
│ ├───┴───┘
│ │
└───┘
```
or intersect each other:
```
┌─────┐
│ │
│ ┌──┼──┐
│ │ │ │
└──┼──┘ │
│ │
└─────┘
```
or overlap each other partially or completely:
```
┌─────┐
├──┐ │
│ │ │
├──┘ │
└─────┘
```
## Challenge description
Write a program that receives a series of positive decimal integers separated by whitespace from standard input. The number of integers you receive is a multiple of four, each set of four integers *x*1 *x*2 *y*1 *y*2 is to be interpreted as the coordinates of two points *x*1 *y*1 and *x*2 *y*2 forming opposing corners of a box. You may assume that for each set of coordinates, *x*1 ≠ *x*2 and *y*1 ≠ *y*2.
The coordinate system originates in the top left corner with *x* coordinates progressing to the right and *y* coordinates progressing downwards. You can assume that no *x* coordinate larger than 80 and no *y* coordinate larger than 25 appears.
Your program shall output in either UTF-8, UTF-16, or Codepage 437 a series of whitespace, carriage returns, line feeds, and box drawing characters such that the output shows the boxes described in the input. There may be extraneous whitespace at the end of lines. You may terminate lines either with CR/LF or just LF but stick to one, stray CR characters are not allowed. You may output any number of lines filled with an arbitrary amount of whitespace at the end of the output.
## Examples
The following input draws the first diagram from the question:
```
1 11 1 3
```
The second diagram is offset a little bit, the leading whitespace and empty lines must be reproduced correctly:
```
17 13 3 7
9 5 5 9
9 13 5 7
```
The third diagram also tests that input is parsed correctly:
```
1 7 1
5 4 10
3 7
```
The fourth diagram:
```
11 5 2 6
5 8 3 5
```
As a final test case, try this fifth diagram:
```
┌─────┬─────┐
┌───┼───┬─┼─┬───┴───┐
│ │ │ │ │ │
└───┼───┴─┼─┴───┬───┘
└─────┴─────┘
```
Which looks like this:
```
9 21 2 4 1
13 4 2 11 5
1 5 17 11 1
2 11 17 4 5
```
## Winning condition
This is code golf. The shortest solution in octets (bytes) wins. Standard loopholes apply, (worthless) bonus points for writing a solution that works on DOS.
[Answer]
# PHP>=7.1, 820 Bytes
```
<?preg_match_all("#(\d+(\s+\d+){3})#s",$_GET[0],$t);$r=($w="array_fill")(1,25,$w(1,80," "));function u($n,$y,$x){global$r;$u=[$z=[" ","│",$c="┤","┐","└",$d="┴",$e="┬",$b="├","─","┘","┌",$a="┼"],["│",$c,$b,$a],[$c,$a],["┐",$c,$e,$a],["└",$d,$b,$a],[$d,$a],[$e,$a],[$b,$a],["─",$d,$e,$a],["┘",$c,$d,$a],["┌",$e,$b,$a],[$a]];$o=$r[$y][$x];$s=array_intersect($u[($k="array_search")($n,$z)],$u[$k($o,$z)]);$r[$y][$x]=reset($s);}foreach($t[1]as$e){[$a,$b,$c,$d]=explode(" ",preg_replace("#\s+#"," ",$e));u("┌",$h=min($c,$d),$f=min($a,$b));u("┐",$h,$g=max($a,$b));u("└",$i=max($c,$d),$f);u("┘",$i,$g);foreach(($l="array_slice")(range($f,$g),1,-1)as$x){u("─",$h,$x);u("─",$i,$x);}foreach($l(range($h,$i),1,-1)as$y){u("│",$y,$f);u("│",$y,$g);}}foreach($r as$v)echo join($v)."\n";
```
-6 Bytes for use `"array_fill"`,`"array_search"`, `"array_slice"` without `"`
+19 Bytes `echo ltrim(rtrim(join($v))."\n","\n");` instead of `echo join($v)."\n";` to print only the necessary Chars
[Online Version](http://sandbox.onlinephpfunctions.com/code/c32d2d88c6252d82b1663c679620072a1621ae85)
Expanded
```
preg_match_all("#(\d+(\s+\d+){3})#s",$_GET[0],$t); # find all rects
$r=($w="array_fill")(1,25,$w(1,80," ")); # fill a empty 2 D array with spaces
function u($n,$y,$x){ # Char , Y Coordinate, X Coordinate as parameter
global$r; # result array must be global to make changes
# The following array based on Set Theory
$u=[
$z=[" ","│",$c="┤","┐","└",$d="┴",$e="┬",$b="├","─","┘","┌",$a="┼"],
["│",$c,$b,$a],
[$c,$a],
["┐",$c,$e,$a],
["└",$d,$b,$a],
[$d,$a],
[$e,$a],
[$b,$a],
["─",$d,$e,$a],
["┘",$c,$d,$a],
["┌",$e,$b,$a]
,[$a]];
$o=$r[$y][$x]; # old value for YX
$s=array_intersect($u[($k="array_search")($n,$z)],$u[$k($o,$z)]); # make the Cut quantity
$r[$y][$x]=reset($s); # Take the first value Cut quantity and set it as new value
}
foreach($t[1]as$e){ # for each rect
[$a,$b,$c,$d]=explode(" ",preg_replace("#\s+#"," ",$e)); #split the four coordinates
# next 4 rows make edges and set minimum and maximum for X an Y values
u("┌",$h=min($c,$d),$f=min($a,$b));
u("┐",$h,$g=max($a,$b));
u("└",$i=max($c,$d),$f);
u("┘",$i,$g);
foreach(($l="array_slice")(range($f,$g),1,-1)as$x){u("─",$h,$x);u("─",$i,$x);} # make the X lines
foreach($l(range($h,$i),1,-1)as$y){u("│",$y,$f);u("│",$y,$g);} # make the Y lines
}
foreach($r as$v)echo join($v)."\n"; # Output
```
## Order of the array Set Theory
```
foreach($u as $k0=>$v0)
foreach($u as $k1=>$v1)
echo "\n\n'".$z[$k0]."' + '".$z[$k1]."' = '". join("','",array_intersect($v0,$v1))."'";
```
[Examples Set Theory all possible values](http://sandbox.onlinephpfunctions.com/code/d392d24132e677f6250ca6b1820fbaa7a10cd43a)
The array without the use of variables to short it
```
$u=[
$z=[" ","│","┤","┐","└","┴","┬","├","─","┘","┌","┼"],
["│","┤","├","┼"],
["┤","┼",],
["┐","┤","┬","┼"],
["└","┴","├","┼"],
["┴","┼"],
["┬","┼"],
["├","┼"],
["─","┴","┬","┼"],
["┘","┤","┴","┼"],
["┌","┬","├","┼"]
,["┼"]];');
```
[Answer]
# CJam, 129
```
0a80*a25*[q~]4/{:(2/:$_::-+e_534915808 6b3/\ff=C2b.+{):A;)z{_A)+\[A!A].+_A)4*+\}*;}%{~:A;_3$=@_2$=A|tt}/}/" ┌ ─┐┬ └│├┘┴┤┼"ff=N*
```
[Try it online](http://cjam.aditsu.net/#code=0a80*a25*%5Bq~%5D4%2F%7B%3A(2%2F%3A%24_%3A%3A-%2Be_534915808%206b3%2F%5Cff%3DC2b.%2B%7B)%3AA%3B)z%7B_A)%2B%5C%5BA!A%5D.%2B_A)4*%2B%5C%7D*%3B%7D%25%7B~%3AA%3B_3%24%3D%40_2%24%3DA%7Ctt%7D%2F%7D%2F%22%20%20%20%E2%94%8C%20%E2%94%80%E2%94%90%E2%94%AC%20%E2%94%94%E2%94%82%E2%94%9C%E2%94%98%E2%94%B4%E2%94%A4%E2%94%BC%22ff%3DN*&input=1%207%201%0A5%204%2010%0A3%207)
Notes:
* If the boxes don't look quite right, it's possible that your browser is using a fallback font for box drawing characters.
* CJam doesn't specify an encoding for source files. In UTF-8, this code has 151 bytes, but you can save it using CP437 or CP850 instead (and run it with the same encoding), then it will use 1 byte/character.
**Overview:**
`0a80*a25*` creates a matrix of 80×25 zeros
`[q~]4/` reads the input, converts to numbers and splits into quadruplets
`:(2/:$_::-+e_` converts an [x1 x2 y1 y2] quadruplet to [xmin xmax ymin ymax -width -height] (negative values will be corrected later)
`534915808 6b3/` generates [[1 2 5] [0 2 5] [0 3 4] [0 2 4]], to be used as indices in the previous array for extracting data about the 4 sides of the current box
`\ff=` extracts the data for each side, e.g. [1 2 5] -> [xmax ymin -height] for the right side
`C2b.+` appends 1, 1, 0, 0 respectively to the arrays for the 4 sides (right, left, bottom, top); this number indicates the direction (0=horizontal, 1=vertical)
`):A;)z{_A)+\[A!A].+_A)4*+\}*;` generates line pieces for a side, as [x y bitmask] triplets; each piece is a line going from the center of the cell to one of 4 directions: 1=right, 2=bottom, 4=left, 8=top; e.g. [4 2 -3 0] (a horizontal line of length 3 starting at x=4, y=2) results in [4 2 1] [5 2 4] [5 2 1] [6 2 4] [6 2 1] [7 2 4]
`{~:A;_3$=@_2$=A|tt}/` bitwise-OR's all these line pieces into the matrix, resulting in bitmasks from 0..15
`" ┌ ─┐┬ └│├┘┴┤┼"ff=` converts these bitmasks to the corresponding box-drawing characters
`N*` joins with newlines for display
[Answer]
# Haskell, ~~399~~ ~~340~~ 398 bytes
-59 (!) bytes thanks to [Ørjan Johansen](https://codegolf.stackexchange.com/users/66041/%c3%98rjan-johansen)
```
import Data.Bits
import Data.Array
(&)=(,)
z=maximum
r x=[minimum x..z x-1]
l=map(+1).r
e(a:b:c:d:q)=[x&y&n|(n,(f,g))<-zip[0..][id&l,id&r,l&id,r&id],x<-f[a,b],y<-g[c,d]]++e q;e[]=[]
f a|m<-z a=unlines[[" UD│L┘┐┤R└┌├─┴┬┼"!!(accumArray setBit 0(1&1,m&m)(e a)!(x,y))|x<-[1..m]]|y<-[1..m]]
main=interact$f.map read.words
```
[Try it online!](https://tio.run/##TU@xTsMwFNz9Fa8VimzVtepShCjNAOrIhMRkeXATt1jEaeukIqk6IGYGBg8MjIyMjHyNfyS4DIjh3bs7PZ3e3avqQRdF1xm7Wbsa5qpW7NrUFfpvXDmnWoQTkmJK0D61qjF2Z5GDJhXWlEcBDWN7aIZcoiIebPCAE@aQxmq6mGbTfLolqWiSNikPuKR4SVeEzIZ7sxEjxqQweVLQCI4WicmpiyBpMxsuhaILSdvZcCUymks5GGjYXmohUyHREtTBxhRQ6a4sTKkrIfpwNw/@@Sb4t@Bfg/@4Dd4H/xL8e/BPwX8F/xn8d7/XwyrLdva3HFS6jrVhhHnCqU0swRoU6eGGtoQc4iOCM2alPLR/FFllytSUtXYqq0@WLLYGp1XOHtcur7ruAsYcxjABjvhpXGPgHM5QHODnR87RrxXFJPo/ "Haskell – Try It Online")
**Ungolfed**
```
import Data.Bits
import Data.Array
import Data.List.Split
(&) = (,) -- Alias for tuples
-- Given [a,b], returns a list of all x: a <= x < b
halfOpenLeft x = [minimum x..maximum x-1::Int]
-- Same as above, but for all x: a < x <= b
halfOpenRight = map(+1).halfOpenLeft
up = ((id, halfOpenRight), 0) -- Coordinates that should have a line upwards
down = ((id, halfOpenLeft), 1) -- Coordinates that should have a line downwards
left = ((halfOpenRight, id), 2) -- Coordinates that should have a line leftwards
right = ((halfOpenLeft, id), 3) -- Coordinates that should have a line rightwards
-- Create a map between coordinates and line-segments. Each coordinate can have multiple line-segments.
lineSegments :: [[Int]] -> [((Int,Int),Int)]
lineSegments rects = [ ((x,y),n) | [x1,x2,y1,y2] <- rects, ((f,g),n) <- [up,down,left,right], x <- f [x1,x2], y <- g [y1,y2]]
-- Convert an array of bit-fields into a list of lines.
printBitfieldArray :: Int -> Array (Int,Int) Int -> [String]
printBitfieldArray size a = [[" UD│L┘┐┤R└┌├─┴┬┼"!!(a!(x,y))|x<-[1..size]]|y<-[1..size]]
-- Merge all the line-segments for each coordinate into a bitfield
createBitFieldArray :: Int -> [((Int,Int),Int)] -> Array (Int,Int) Int
createBitFieldArray m = accumArray setBit 0 ((1,1),(m,m))
-- First split the input for each rectangle,
-- then create a list of pairs of coordinates and directions,
-- then merge all directions for each coordinate into a bitfield
-- and finally use the bitfield as an index to find out which shape to draw.
drawRectangles :: Int -> [Int] -> [String]
drawRectangles m=printBitFieldArray m.createBitFieldArray m.lineSegments.chunksOf 4
-- Parse the input, solve the problem and format the output. Use the largest number as both width and height.
main=interact$unlines.(drawRectangles=<<maximum).map read.words
```
## Explanation
1. First, `lineSegments` (or `d` in the golfed version) will loop over all rectangles, all directions and all coordinates that should have a line-segment in that direction from that rectangle and create a list of coordinates paired with directions.
2. Then `createBitFieldArry` merges all entries with identical coordinates into an array of bitfields. Here, the 0th bit means up, 1st means down, 2nd means left and the 3rd means right. In other words, 5 is rendered as "┘", 0 is " " and 15 is "┼".
3. Lastly, `printBitFieldArray` (or `p`) converts the bitfields into box-drawing characters by using them as indices.
[Answer]
# Python 3, 632 bytes
```
i=input()
j=''
while i:j+=i+' ';i=input()
c=[int(k)-1for k in j.split()]
c=[c[k:k+4]for k in range(0,len(c),4)]
for q in c:
for v,w in[(0,1),(2,3)]:
if q[w]<q[v]:t=q[w];q[w]=q[v];q[v]=t
d=list(zip(*c))
w=max(d[1])+1
h=max(d[3])+1
g=[0]*w*h
def i(a,b,f):
for k in b:
for l in a:g[k*w+l]|=f[0];f=f[1:]
def p(k,l,m,n,o,j=0):
for i in range(m,n,o):l[i]|=k
if j:p(k,l,m+j,n+j,o)
for q in c:i(q[:2],q[2:],[6,12,3,9]);p(10,g,q[0]+1+q[2]*w,q[1]+q[2]*w,1,(q[3]-q[2])*w);p(5,g,q[0]+q[2]*w+w,q[0]+q[3]*w,w,q[1]-q[0])
print('\n'.join(map(lambda k: ''.join(map(lambda x: ' └ │┌├ ┘─┴┐┤┬┼'[x], k)),[g[x:x+w]for x in range(0,len(g),w)])))
```
[Answer]
## Node, 536 bytes
```
s=''
with(process.stdin){setEncoding('utf8')
on('readable',_=>s+=read()||'')
on('end',_=>{a=s.match(/(\d+\s+){3}\d+/g).map(s=>s.match(/\d+/g).map(m=>+m)).map(([m,n,o,p])=>[m>n?n:m,m>n?m:n,o>p?p:o,o>p?o:p])
m=i=>[...Array(Math.max(...a.map(a=>a[i])))]
console.log(m(3).map((_,y)=>m(1).map((_,x)=>' ??┘?│┐┤?└─┴┌├┬┼'[x++,a.some(([m,n,o,p])=>x==m|x==n&&y>o&y<=p)+2*a.some(([m,n,o,p])=>y==o|y==p&&x>m&x<=n)+4*a.some(([m,n,o,p])=>x==m|x==n&&y>=o&y<p)+8*a.some(([m,n,o,p])=>y==o|y==p&&x>=m&x<n)],y++).join``).join`\n`)})}
```
Directly calculates the correct character at each coordinate. Input is annoying to perform in Node...
] |
[Question]
[
Given a number and either "+" or "\*", return an addition or multiplication table with the dimensions of that number.
## Specifications
* The input will be formatted as `dimension, operation`.
* The program should not return anything if the operation input is not + or \*.
* The program should not return anything if the dimension input is less than 1.
```
(4,*):
1 2 3 4
2 4 6 8
3 6 9 12
4 8 1216
(4,+):
1234
2456
3567
4678
```
The spaces between the numbers in the table should be equal to one less than the number of digits in `dimension^2` for multiplication, and for addition one less than the number of digits in `dimension * 2`.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + BSD Utils, 62 bytes
```
l=$[$1*$1-1]
eval echo \$[{1..$1}$2{1..$1}]|rs -g${#l} $[$1+1]
```
This calculates the number of spaces as per "number of digits in (dimension^2)-1", and not as shown in the example output, as currently written.
[Try it online!](https://tio.run/##S0oszvj/P8dWJVrFUEvFUNcwliu1LDFHITU5I18hRiW62lBPT8WwVsUIyoitKSpW0E1XqVbOqVUAadI2jP3//7@hwX8tAA "Bash – Try It Online")
This answer is very similar to [this one](https://codegolf.stackexchange.com/a/67902/11259).
Works out-of-the-box on macOS. `rs` may need to be installed on Linux systems:
```
sudo apt-get install rs
```
[Answer]
# Excel, 74 bytes
Worksheet funtion that takes input of `dimension, operation` from `A1, B1` and output a square array starting at the calling cell. Error handling accounts for a large portion of this response, and it is likely that large optimizations may be made to it.
```
=IfError(Let(r,Sequence(A1),c,Transpose(r),Ifs(B1="*",r*c,B1="+",r+c)),"")
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 22 bytes
```
FN>¹L².VvyDg¹ngs-ú}J,}
```
[Try it online!](https://tio.run/nexus/05ab1e#@@/mZ3dop8@hTXphZZUu6Yd25qUX6x7eVeulU/v/v6EhlxYA "05AB1E – TIO Nexus")
Also works with `-`, `^`, `m` and many more. See [here](https://github.com/Adriandmen/05AB1E/blob/master/Info.txt) for a list of commands this could work with by searching for "pop a,b".
Output (4,+):
```
2 3 4 5
3 4 5 6
4 5 6 7
5 6 7 8
```
Output (4,\*):
```
1 2 3 4
2 4 6 8
3 6 912
4 81216
```
Output (4,^) [XOR]:
```
0 3 2 5
3 0 1 6
2 1 0 7
5 6 7 0
```
Output (4,c) [nCr]:
```
1 2 3 4
0 1 3 6
0 0 1 4
0 0 0 1
```
Output (4,Q) [a == b]:
```
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
```
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 11 bytes
```
{(⍳∘.⍺⍺⍳)⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/41HbhGqNR72bH3XM0HvUuwuMNms@6t1a@/9R31SgrHaGggkXhKmuCwbqUK4WTpnD00FS/wE "APL (Dyalog Classic) – Try It Online")
# APL NARS, 22 bytes, 11 chars
```
{(⍳∘.⍺⍺⍳)⍵}
```
test:
```
h←{(⍳∘.⍺⍺⍳)⍵}
×h 4
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
+h 4
2 3 4 5
3 4 5 6
4 5 6 7
5 6 7 8
*h 7
1 1 1 1 1 1 1
2 4 8 16 32 64 128
3 9 27 81 243 729 2187
4 16 64 256 1024 4096 16384
5 25 125 625 3125 15625 78125
6 36 216 1296 7776 46656 279936
7 49 343 2401 16807 117649 823543
```
even if {(⍳∘.⍺⍺⍳)⍵} seems to be ok, {(⍳∘.⍵⍵⍳)⍺} it seems not ok
```
f←{(⍳∘.⍵⍵⍳)⍺}
4 f×
SYNTAX ERROR
```
Possible spaces are not as the examples in the question too...
h with g h n is the operator generator of table nxn For each diadic function g. In particular =h n is unit matrix for nxn.
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 111 bytes
```
{s=$2=="*"?2:$2=="+"?1:0;for(i=s-2;s&&++i<=$1;print"")for(j=s-2;++j<=$1;)printf("%"(s==1?2:$1)"s",s>1?i*j:i+j)}
```
[Try it online!](https://tio.run/##HcxBCsMgEEDRfY4xpEEdA1VCFtqpu96jm8BYiCET6KL06rXE3YcH//l@1foR6j0RGEg@tEJILlzjUnbFJKOPMgyIfKPexW3n9QDQJ@aGiLmJbrQouIASInfenAYBK3eX2OTAmPW31sliN1nTzRZ/ZTu4rFLHh/0D "AWK – Try It Online")
Output formatting may be slightly different than requested.
```
Input:
4,+
4,*
6,+
Output:
0 1 2 3 4
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
0 1 2 3 4 5 6
1 2 3 4 5 6 7
2 3 4 5 6 7 8
3 4 5 6 7 8 9
4 5 6 7 8 910
5 6 7 8 91011
6 7 8 9101112
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 123 bytes
```
-Dp(i,c)for(i==0;i++<n;c)
-Df(c)if(x===*#c)p(i,puts(""))p(j,printf("%d ",i c j));
n;x;main(i,j){scanf("%d%c",&n,&x);f(+)f(*)}
```
[Try it online!](https://tio.run/##HY1BCsIwEEWvEiItM0kKunCVZudFwsiUCRpDU6EgXt0YXX7ee3yaFqLWst/9PUoGcQlflWJm0MN1IO3G7MYdPYNFBoPv1k5n8yG@xaW26VJ6QsiPFSSEoxdr5@wJO2EgFIY9hGAOhD@xPLcKWmMfyZVV8va/UdqJIpUQ/Rc "C (gcc) – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 22 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
+17 bytes for the input validation and output formatting! :o
```
õ ïV ú f@©"*+"øVÃòU mq
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=9SDvViD6IGZAqSIqKyL4VsPyVSBtcQ&input=NAoiKiI)
[Answer]
# Mathematica, 46 bytes
```
Grid@Outer[If[#2=="+",Plus,Times],r=Range@#,r]&
```
Unnamed function taking two arguments, a number and one of the characters "+" or "\*".
Sample output for the arguments `12`,`"*"`:
[](https://i.stack.imgur.com/fG01X.png)
[Answer]
# JavaScript, 137 bytes
```
f=(n,s,b="")=>{for(i=0;i++<n;b+="\n")for(j=0;j++<n;b+=(r=s=='*'?i*j:s=='+'?i+j:"")+" ".repeat((n**2+"a").length-(r+"").length));return b}
```
Creates function `f` that returns the string. This calculates the number of spaces as per `number of digits in (dimension^2)-1`, and not as shown in the example output, as currently written. Outputs nothing if there is something other than `+` or `*`. I'm open to golfing tips.
### Explanation
```
f=(n,s,b="")=>{
for(i=0;i++<n;b+="\n")
for(j=0;j++<n;b+=(r=s=='*'?i*j:s=='+'?i+j:"")+" ".repeat((n**2+"a").length-(r+"").length));
return b
}
```
*I like when most of my code is just in my for-loops :)*
`n` is the number; `s` is the operator; `b` is the string that contains the output; `r` contains the actual value of the table cells
This is a system of two nested for-loops, I add `b` by `i*j` or `i+j` depending on the operator `(r=s=='*'?i*j:s=='+'?i+j:"")`, and then add the spaces afterward `" ".repeat((n**2+"a").length-(r+"").length)`.
At the end of the `j`-for-loop, I concatenate a newline to `b`.
### Snack Snippet
```
f=(n,s,b="")=>{for(i=0;i++<n;b+="\n")for(j=0;j++<n;b+=(r=s=='*'?i*j:s=='+'?i+j:"")+" ".repeat((n**2+"a").length-(r+"").length));return b}
console.log(f(10,'+'));
```
[Answer]
## JavaScript (ES6), 160 bytes
```
(n,s,w=`${s==`*`?n*n:n+n}`.length)=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>((s==`*`?++j*i+j:s==`+`?i+j+2-!(i&&j):``)+` `.repeat(w)).slice(0,w)).join``).join`\n`
```
Where `\n` represents the literal newline character. Takes care to space the grid properly for both `+` and `-` versions, and ensures the first row and column are the dimensions and not the sum.
[Answer]
# Python 3 - ~~154~~ 133 ~~127~~ bytes
```
def s(d,o):R,s=range(1,d+1),' '*len(str((d,2)[o=='+']*d-1));return''.join([str((i*j,i+j)[o=='+'])+s+'\n'*(i==d)for j in R for i in R])
```
**Edit** : Changed spacing between number according to the new changes in the question.
```
Input :
8 +
Output :
2 3 4 5 6 7 8 9
3 4 5 6 7 8 9 10
4 5 6 7 8 9 10 11
5 6 7 8 9 10 11 12
6 7 8 9 10 11 12 13
7 8 9 10 11 12 13 14
8 9 10 11 12 13 14 15
9 10 11 12 13 14 15 16
```
[Answer]
# [R](https://www.r-project.org/), 48 bytes
```
function(n,o)write(format(outer(1:n,1:n,o)),1,n)
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jTydfs7wosyRVIy2/KDexRCO/tCS1SMPQKk8HhPM1NXUMdfI0/6dpGBrpKGkpaXJBWNpKmv8B "R – Try It Online")
Same I/O as the accepted answer.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 18 bytes
```
ɾ?\vdpĖ:vvS$fGL↲Ṡ⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLJvj9cXHZkcMSWOnZ2UyRmR0zihrLhuaDigYsiLCIiLCI0XG4qIl0=)
Without strict IO formats, the whole `:vvS$fGL↲Ṡ⁋` could be omitted
[Answer]
## Python 3 - 140 bytes
```
a=lambda d,o:print(*map(lambda f:(' '*~-len(str([d,2][o>'*']*d))).join([str([i*f,i+f][o>'*'])for i in range(1,d+1)]),range(1,d+1)),sep='\n')
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 91 bytes
```
(n,_)=>[...'.'.repeat(n)].map((a,i)=>Array.from({length:n},(v,k)=>_='*'?(k+1)*(i+1):k+i+1))
```
[Try it online!](https://tio.run/##FYpRCsIwEESP000bFwS/ClE8h0hZalJj0k1IQ0HEs8eVgRl4b1600zYXn@uB08M2ZxqwnpQ53xCxkxSbLVVgdceVMgBpL/ZaCr3RlbTCJ1pe6nPkr4ZdB5GT6fruAmE4qh689BiG/6g2J95StBjTAg5OWn5Cfw "JavaScript (Node.js) – Try It Online")
] |
[Question]
[
Write a program, that takes 5 numbers as input and outputs the next number in the pattern.
Heres a text file with [1835 test patterns](https://drive.google.com/file/d/0B4vI8G7V69KsYk5sb2o5dUN0NEE/edit?usp=sharing), containing 6 numbers separated by commas each line. Using the first 5 numbers calculate the 6th number and then check if it matches. You must get all the test cases correct.
There are 3 types of patterns:
1. xn = xn-1+k
2. xn = xn-1\*k
3. xn = xn-1^2
The first x value and k were chosen randomly between a set range to create the pattern sample file.
This is code-golf, lowest number of bytes to get all of the test cases correct wins.
[Answer]
## Python 2: 55 bytes
```
f=lambda a,b,c,d,e:e+c-d*2and e*e/d**(d*d==e*c)or e*2-d
```
We check for the three cases as follows:
1. Check for arithmetic sequence: If `e+c==d+d`, output `e+e-d`
2. Check for geometric sequence: If `e*c==d*d`, output `e*e/d`
3. Otherwise, squared sequence: Output `e*e`.
Case 3 is used as the else-case to avoid the more-lengthy checking for successive squaring.
Case 1 is checked first, with Boolean short-circuiting to avoid checking Case 2 after a success, as this causes an error when `d=0`. There's a test case of all zeroes, so we can't cheat this by picking another position in place of `d`.
Afterwards, we can treat both Cases 2 and 3, since there's no risk of a divide-by-0 error. Noting that the choices are similar (`e*e` vs `e*e/d`), we combine them with an arithmetic expression by dividing by either `d**1` for Case 3 or `d**0` for Case 2. Although this division produces an integer value, we must use Python 2 (or `//`) to avoid float errors that case the largest-output test case to fail.
Thanks to @Will for inspiration on the code structure and a very-helpful test framework.
[Answer]
## Python all right, 72 ~~74~~ ~~75~~ chars
```
p=lambda i,j,k,l,m:j-i!=k-j and(k==j*j==j*i*i and m*m or m*l/k)or m+j-i
```
Thx to **xnor** for showing me the `if`/`else` to `and`/`or` trick and golfing off a char :)
Thx to **flornquake** for fixing the `k==j*j==j*i*i` and saving another two chars :)
Actually, it gets one wrong... but that's a bug in the test patterns which was acknowledged yesterday but still not fixed.
Testing code, hopefully useful for all competitors to test with:
```
def check(func,title):
right = 0
print "===", title, "==="
for i,test in enumerate(open('patterns.txt')):
test = map(int,test.split(','))
try:
got, expected = func(*test[:5]), test[5]
except Exception as e:
got = e
if got != expected:
print "ERROR on line %d: %s != %d" % (i, got, expected)
print " test :", ", ".join(map(str,test))
plus = multi = cube = str(test[0])
for i in range(1, 6):
plus += ", %d" % (test[i-1]+(test[1]-test[0]))
multi += ", %s" % ((test[i-1]*(test[1]/test[0])) if test[0] else "DivZero")
cube += ", %d" % (test[i-1]**2)
print " as + :", plus
print " as * :", multi
print " as ^2:", cube
else:
right += 1
print right, "out of", i+1, "right!"
```
says:
```
ERROR on line 19: 23283064365386962890625 != 3273344365508751233
test : 5, 25, 625, 390625, 152587890625, 3273344365508751233
as + : 5, 25, 45, 645, 390645, 152587890645
as * : 5, 25, 125, 3125, 1953125, 762939453125
as ^2: 5, 25, 625, 390625, 152587890625, 23283064365386962890625
1834 out of 1835 right!
```
[Answer]
## C# - 1835
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace pattern
{
class Program
{
static void Main(string[] args)
{
string[] lines = File.ReadAllLines("in.txt");
int matches = 0;
for(int i = 0; i < lines.Length; i++)
{
long[] numbers = lines[i].Split(',').Select(a=>long.Parse(a)).ToArray();
long nextnum = 0;
if(numbers[1]-numbers[0]==numbers[2]-numbers[1])
nextnum = numbers[numbers.Length-2]+(numbers[1]-numbers[0]);
else if(numbers[1]/numbers[0]==numbers[2]/numbers[1])
nextnum = numbers[numbers.Length-2]*(numbers[1]/numbers[0]);
else if(numbers[1] == numbers[0]*numbers[0])
nextnum = numbers[numbers.Length-2]*numbers[numbers.Length-2];
if(nextnum == numbers[numbers.Length-1])
matches++;
}
Console.WriteLine(matches + " matches found!");
Console.ReadLine();
}
}
}
```
This is obviously not golfed at all, but it finds all numbers eventually. It just prints how many matches it found, but you could potentially display all found numbers, only non-matches, etc...
*(This is conceptually very similar to Beta Decay's answer, just a little bit more complicated)*
[Answer]
# Python 3 -1833
## Length 198 chars
Now updated to conform to the rules.
```
m=0
for i in open('s'):
if','in i:
i,j,k,l=list(map(int,i.split(',')[2:]))
if j-i==k-j:
if k+(j-i)==l:m+=1
elif j/i==k/j:
if k*(j/i)==l:m+=1
elif i**2==j:
if k**2==l:m+=1
print(m)
```
[Answer]
# TI-BASIC, ~~120~~ ~~117~~ 136
Prompts for input and returns the output.
```
Input L1:0:If not(L1(5:Stop
If L1(5)-L1(4)=L1(4)-L1(3:L1(5)+(L1(5)-L1(4
If L1(5)/L1(4)=L1(4)/L1(3:L1(5)(L1(5)/L1(4
If L1(4)²=L1(5:L1(5)²
```
**Edit:** Fixed divide by zero error.
] |
[Question]
[
Today our lesson is about rectangles and triangles.
you will be given as an input an `n x n` grid that is based on two characters `#` and `*`
you have to classify it into : triangle or rectangle.
where `#` represents a point and `*` represents a blank space.
# Example input:
```
#***
##**
###*
####
```
## Output:
```
triangle
```
## Another example
```
##**
##**
##**
##**
```
# Output:
```
rectangle
```
Rules:
* You should assume that the input is always either a triangle or a rectangle.
* The only two characters you will receive are: `*` and `#`.
* Assume that n < 100.
* Be creative, this is a [popularity-contest](/questions/tagged/popularity-contest "show questions tagged 'popularity-contest'") so the most up-voted answer will win.
[Answer]
**TSQL**
Image recognition? Sounds like a job made for SQL :)
```
WITH cte AS (
SELECT LEN(data)-LEN(REPLACE(data,'#','')) c FROM test_t
)
SELECT
CASE WHEN COUNT(DISTINCT c)>2 THEN 'triangle'
WHEN SUM(CASE WHEN c=0 THEN 0 ELSE 1 END) = MAX(c) THEN 'square'
ELSE 'rectangle'
END result
FROM cte;
```
[An SQLfiddle with sample data and test](http://sqlfiddle.com/#!6/4f49e/1).
[Answer]
## Python
**Creativity**
*Triangle*
```
Forward Reverse
#*** #### ####
##** + *### = ####
###* **## ####
#### ***# ####
```
*Rectangle*
```
Forward Reverse
##** ##** ##**
##** + ##** = ##**
##** ##** ##**
##** ##** ##**
```
**Implementation**
```
s=raw_input();print["tri","rect"][all(a!=b for a,b in zip(s,s[::-1])if a!='\n')]+"angle"
```
[Answer]
## Python + Sympy
A problem in Geometry should be only solved mathematically
**Creativity**
if s if the number of "#" in the input stream
Triangle: `n**2+n-2s=0` -> n should be an integer
**Implementation**
```
from sympy import *
s,n=2*raw_input().count("#"),Symbol('n');print["rect","tri"][float(solve(n**2+n-s)[0]).is_integer()]+"angle"
```
[Answer]
## C
**Assumption**: the input does not represent a single-line degenerate rectangle, e.g.
```
****
*##*
****
****
```
as arguably this is also a degenerate triangle, and violates "the input is always one of the two cases."
**Logic**: Count the number of points in the first two non-empty lines. If they are the same, it is a rectangle. Otherwise, it is a triangle.
**Code**:
```
#include <stdio.h>
#include <string.h>
int main() {
char s[99];
int cnt1=0, cnt2=0;
int i;
while(!cnt1) {
gets(s);
for(i=0;i<strlen(s);i++) cnt1+=(s[i]=='#');
};
gets(s);
for(i=0;i<strlen(s);i++) cnt2+=(s[i]=='#');
puts(cnt1==cnt2?"rectangle":"triangle");
return 0;
}
```
[Answer]
# Java
A simple straightforward java implementation. It scans the input looking for some 2x2 square which have `#` in two opposing corners with something not a `#` (presumable a `*`) is some other corner. I.E, it searchs for something that shows that the drawing has a diagonal-lined border.
```
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class TrianglesAndRectangles {
public static void main(String[] args) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int r;
while ((r = System.in.read()) != -1) {
baos.write(r);
}
String[] lines = baos.toString().split("\n");
System.out.println(hasTriangle(lines) ? "triangle" : "rectangle");
}
public static boolean hasTriangle(String[] lines) {
for (int i = 0; i < lines.length - 1; i++) {
for (int j = 0; j < lines[i].length() - 1; j++) {
boolean a = lines[i].charAt(j) == '#';
boolean b = lines[i].charAt(j + 1) == '#';
boolean c = lines[i + 1].charAt(j) == '#';
boolean d = lines[i + 1].charAt(j + 1) == '#';
if ((a && d && (!c || !b)) || (b && c && (!a || !d))) return true;
}
}
return false;
}
}
```
] |
[Question]
[
**Task**
Inputs \$b \leq 100\$ and \$n \geq 2\$. Consider \$n\$ binary strings, each of length \$b\$ sampled uniformly and independently. We would like to compute the expected minimum [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) between any pair. If \$n = 2\$ the answer is always \$b/2\$.
**Correctness**
Your code should ideally be within \$\pm0.5\$ of the correct mean. However, as I don't know what the correct mean is, for values of \$n\$ which are not too large I have computed an estimate and your code should be within \$\pm0.5\$ of my estimate (I believe my estimate is within \$\pm0.1\$ of the correct mean). For larger values than my independent tests will allow, your answer should explain why it is correct.
* \$b = 99, n = 2^{16}.\$ Estimated avg. \$19.61\$.
* \$b = 89, n = 2^{16}.\$ Estimated avg. \$16.3\$.
* \$b = 79, n = 2^{16}.\$ Estimated avg. \$13.09\$.
* \$b = 69, n = 2^{16}.\$ Estimated avg. \$10.03\$.
* \$b = 59, n = 2^{16}.\$ Estimated avg. \$7.03\$.
* \$b = 99, n = 2^{15}.\$ Estimated avg. \$20.67\$.
* \$b = 89, n = 2^{15}.\$ Estimated avg. \$17.26\$.
* \$b = 79, n = 2^{15}.\$ Estimated avg. \$13.99\$.
* \$b = 69, n = 2^{15}.\$ Estimated avg. \$10.73\$.
* \$b = 59, n = 2^{15}.\$ Estimated avg. \$7.74\$.
* \$b = 99, n = 2^{14}.\$ Estimated avg. \$21.65\$.
* \$b = 89, n = 2^{14}.\$ Estimated avg. \$18.23\$.
* \$b = 79, n = 2^{14}.\$ Estimated avg. \$14.83\$.
* \$b = 69, n = 2^{14}.\$ Estimated avg. \$11.57\$.
* \$b = 59, n = 2^{14}.\$ Estimated avg. \$8.46\$.
**Score**
Your base score will be the number of the examples above that your code gets right within \$\pm0.5\$. On top of this you should add \$x > 16\$ for the largest \$n = 2^x\$ for which your code gives the right answer within \$\pm0.5\$ for all of \$b = 59, 69, 79, 89, 99\$ (and also all smaller values of \$x\$). That is, if your code can achieve this for \$n=2^{18}\$ then you should add \$18\$ to your score. You only get this extra score if you can also solve all the instances for all smaller \$n\$ as well. The number of strings \$n\$ will always be a power of two.
**Time limits**
For a single \$n, b\$ pair, your code should run on [TIO](https://tio.run/#) without timing out.
**Rougher approximation answers for larger values of \$n\$**
For larger values of \$n\$ my independent estimates will not be as accurate but may serve as a helpful guide nonetheless. I will add them here as I can compute them.
* \$b = 99, n = 2^{17}.\$ Rough estimate \$18.7\$.
* \$b = 99, n = 2^{18}.\$ Rough estimate \$17.9\$.
* \$b = 99, n = 2^{19}.\$ Rough estimate \$16.8\$.
[Answer]
# [Python 3](https://docs.python.org/3/), score = big(?)
```
from math import exp, log, log1p
def f(b, n):
e = n * (n - 1) / 2
m = 0
c = 1
s = 0
t = 1 << b
for k in range(b):
s += c
m += exp(e * (log1p(-s / t) if 2 * s < t else log((t - s) / t)))
c = c * (b - k) // (k + 1)
return m
```
[Try it online!](https://tio.run/##RZDRbsIwDEXf@xVXPCVQxMoGW1H5kokH0iVQlaRVGqSiqt/eOe7URXJkXzv2cdpXuDfufZqMbyzsNdxR2bbxAbpvUzyaG19ZmyQ/2sAIlcLJUwI6Gmc4rCEctsgkdtizbkl/Y68kL2OvW7QQNRQFFIem8ahROfiru2mh/nrPbzZnlEtoY0hUQseZDCW2HU0NEpXBntQOBfXXj05HaCECgXWSS6RcGkWqMvZQlK4pvYOosaEVuMTr8PQOdopofUT7zo4psgPZx@W0UCtO5XmKL7JPsiPZIb/8b9D6ygVhVkYMakwj4hpDP0oCGPgrWenluJpHz/Vy@gU "Python 3 – Try It Online")
The Hamming distance \$D\_{x, y}\$ between any two of the strings (\$1 \le x < y \le n\$) is a random variable distributed as the Binomial distribution \$B{\left(b, \tfrac12\right)}\$:
$$
\Pr[D\_{x, y} > k] = 1 - \frac{1}{2^b} \sum\_{i=0}^k \binom bi.
$$
Furthermore, any (distinct) *two* of these \$\binom n2\$ random variables are independent.
If we make the incorrect but empirically useful assumption that *all* \$\binom n2\$ of these random variables are independent, then we can compute the distribution of their minimum \$D = \min\_{1 \le x < y \le n} D\_{x,y}\$ exactly:
$$
\begin{gather\*}
\Pr[D > k] = \left(1 - \frac{1}{2^b} \sum\_{i=0}^k \binom bi\right)^{\binom n2}, \\
\mathbb E[D] = \sum\_{k=0}^{b-1} \Pr[D > k].
\end{gather\*}
$$
This result can be computed extremely quickly and seems to be close enough. Numerical evidence suggests that the absolute error is worst at \$b = 1, n = 3\$ (where we estimate the expected minimum as \$\tfrac18\$ when it is actually \$0\$), and drops off quickly to zero as \$b\$ and/or \$n\$ get large.
] |
[Question]
[
**This question already has answers here**:
[Program that outputs a program that outputs a program ... that outputs "Hello!"](/questions/6544/program-that-outputs-a-program-that-outputs-a-program-that-outputs-hello)
(13 answers)
Closed 5 years ago.
# Input
A string `s` of printable ASCII characters, newlines, and spaces (`0x20 ( )` to `0x7E (~)`), and a non-negative integer `n`.
# Challenge
To write a program that outputs either another program, or `s` depending on `n`. If `n = 1`, Then your code should output code which outputs `s`. If `n = 2`, Your code should output code which outputs code which outputs `s` and so on.
All outputted code should be in the same language as the language of the original submission.
# Test Cases
Format: `s, n -> output`
Assuming your submission is written in JavaScript:
```
No cycles, 0 -> No cycles
Hello, 1 -> console.log("Hello");
Cycle!, 3 -> console.log("console.log(\"console.log(\\\"Cycle!\\\")\")");
:), 3 -> console.log("console.log('console.log(`:)`)')");
```
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so aim for shortest code in bytes.
# Additional Rules
* I/O format is flexible
* Default rules and standard loopholes apply.
* The output of your submission must be valid.
* You can use any language, even if it was created after this challenge, as long as it wasn't created for the purpose of this challenge
* This isn't a polyglot challenge. A JavaScript submission shouldn't output Ruby code.
* Input is guaranteed to be valid as defined in the `Input` section
# Validation
Here's a quick tip to test your answers:
For `n=0`, `output=s`
For `n=1`, `eval(output)=s`
For `n=2`, `eval(eval(output))=s`
Where `n` and `s` are inputs
[Answer]
# [R](https://www.r-project.org/), 43 bytes
```
f=function(s,n)"if"(n,function()f(s,n-1),s)
```
[Try it online!](https://tio.run/##K/r/P802rTQvuSQzP0@jWCdPUykzTUkjTwcuppkGEtY11NQp1vyfpqGUkZqTk6@kY6ypAYZcQCEPiJCB5n8A "R – Try It Online")
Returns a zero-argument function that recursively calls `f` with `n` set to `n-1`. `n` successive function applications returns `s`.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 3 bytes
```
ÀII
```
[Try it online!](https://tio.run/##K/v//3CDp@f//x6pOTn5CuH5RTkp/40B "V – Try It Online")
Takes string as input, prepends as many `I` as stated in the first argument.
[Answer]
# Google Sheets, 96 bytes
```
=Join("",If(B1,ArrayFormula("="&Rept("""",2^(Row(Offset(A1,0,0,B1))-1))),),A1,Rept("""",2^B1-1))
```
Inputs are in cells `A1` (`s`) and `B1` (`n`).
[](https://i.stack.imgur.com/HAGQs.png)
(Columns D, E, and F show the result if you copy the output from the column to its left and input it as a formula.)
---
The formula concatenates 3 pieces into a single string. The first piece is the most complicated.
```
If(B1,ArrayFormula("="&Rept("""",2^(Row(Offset(A1,0,0,B1))-1))),)
```
If `If` statement drops the prefix if `n=0` so you end up with `No cycles` instead of `="No cycles`. The `ArrayFormula` creates an array of equal signs followed by some number quotes. That number is `2^(x-1)` where `x` counts up from 1 to `n` thanks to the `Row(Offset(~))` combination.
The next piece (`A1`) adds in `s` and the final piece (`Rept("""",2^B1-1)`) adds in `2^n-1` quotes at the end.
[Answer]
# [PHP](https://php.net/), 69 bytes
```
function($s,$n){while($n--)$s='echo'.var_export($s,1).';';return $s;}
```
[Try it online!](https://tio.run/##jcoxCsIwFADQPaf4w4ffQBuojrE4CR0Eu7kUitSEFEISklQF8eyRXkB88wsmlMMxmMAYauig6NXNefGuwlSj4@@nWayq0DUNx9SRmo0n8bjFSb2Cj3lrLRckSUaV1@gAk/wUydg2AXVFvbLWw0hXH@19JKqh5SBg6IfpdDnLX3H3b9xzWb4 "PHP – Try It Online")
From the [documentation](https://secure.php.net/manual/en/function.var-export.php) about `var_export`:
>
> var\_export — Outputs or returns a parsable string representation of a variable
>
>
>
This function calls `var_export` prepends `echo` and appends `;` `$n` times.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 25 bytes
```
{'{Q«'x$^n~$^s~'»}'x$n}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/Wr068NBq9QqVuLw6lbjiOvVDu2uBvLza/2n5RQoaBjoK6n75CsmVyTmpxeqaOgoahkARj9ScnHwwzxjIcwZJKsK47/cuUkhMSlZQV4rJe793saaCrp2ChkqejoJKsaZCNRcn0GKV5PyUVAVbhTSYuDUXZ3EiVBzIhskrgRkxGppKeq5hjj4KIBfFqeShqq79DwA "Perl 6 – Try It Online")
Function returning function code. Uses `Q« »` to quote unescaped ASCII strings.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 43 bytes
*Outputs a program that outputs a program that outp.... until `b=1`*
```
f=(a,b)=>b?--b?`(f=${f})('${a}',${b})`:a:''
```
[Try it online!](https://tio.run/##dclBCoQgFADQ/ZwiQvB/0KhmF1hX6VtZM0g/KtqIZ7cL1Nu@P110DPtvO/XK45SSM0DKomltp7XtenBGBBcRpAgUpRLBRuwbaqRMA68H@6nwPIODfGFPucq@iJ/nqV@nep0SMd0 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 42 bytes
```
s#n|n<1=s|0<1="main=putStr"++show(s#(n-1))
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/v1g5rybPxtC2uMYASCrlJmbm2RaUlgSXFClpaxdn5JdrFCtr5Okaamr@B8kp2CrkJhb4KmjEVCjo2ilAVPrkKagoKHkAzctXVFKu0FSINtDTM479DwA "Haskell – Try It Online")
[Answer]
# PHP, 12+1 bytes, not competing
plain text is a valid PHP program, but, if `N` is not `0`, this fails for text containing `<?` with short tags enabled and for text containing `<?php` or `<?=` in any case:
```
<?=$argv[1];
```
call with `php -R '<code>' '<string>' <n>`;
call the output with `php -R '<code>'`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
Ṿ¡
```
[Try it online!](https://tio.run/##y0rNyan8///hzn2HFv7//7/4vxEA "Jelly – Try It Online")
[Answer]
# Python, 55 bytes
```
c=lambda s,n:c("(lambda:"+repr(s)+")()",n-1)if n else s
```
[Answer]
# [C (clang)](http://clang.llvm.org/), `-DA=asprintf(` `-lm` 136 bytes
```
j,*c,*e;f(a,b){A&c,"%s",a);for(;b--;){e="";for(j=1;j++<pow(2,b);A&e,"\\%s",e));A&c,"puts(%s\"%s%s\");",e,c,e);}puts(c);}
```
[Try it online!](https://tio.run/##Xc9LasMwEAbgtX0KIUiQlFET2U4KUb0wdNFVT5CNLKQ0Rn5gJbRgcvW6sqFgvJnRz8doGM21U811HCtgGpiRligo6VBsNeCNx6CotG1PZMm5pIPJMZ5zlQtZ7XZvXftNkjAgi60BfLlMI4ZOMcx3j7snG38JH02VymCgg8vnTDo8xltzR7W6NYQOcbRniJzglFJEjpCK0DIQx9BSeA01gUkECPqCPh91aXrUWuSd8l/Gn0nC2A/lArF9HM0LcJMfzmFvHFmCP4xzLYbDFP9VrFUsNVlrstR0relSs7VmIT7HX22duvqRvxe58l0frrdk5K7@Aw "C (clang) – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Catalan Numbers](/questions/66127/catalan-numbers)
(57 answers)
Closed 6 years ago.
Write a function that calculates a row of the pascal triangle and returns the middle number, if there are 2 it should return their sum.
Example:
`5`
would return
`20`
Example 2:
`4`
would return
`6`
**EDIT:**
To be clear:
a) if the number inputted is odd then find then return the middle number of a row on the pascal triangle.
b) if the number inputted is even then find the two middle numbers of the row on the pascal triangle and sum the 2 numbers.
The nth row is using zero-based indicies. For numbers other than zero, this is the row which has its second number as the number inputted into the function.
[Answer]
# [Ohm](https://github.com/MiningPotatoes/Ohm), 6 bytes
```
½⌠Ddac
```
[Try it online!](https://tio.run/##y8/I/f//0N5HPQtcUhKT//@3AAA "Ohm – Try It Online")
If the number is even it is you calculate (n n/2) if it is odd (n+1 (n+1)/2)
```
Inplicit input
½ Half
⌠ Ceil
D Duplicate on stack
d x2
a Swap on stack
c Binomial
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~7~~ 5 bytes
Saved 2 bytes using the duplicate/swap technique from [FrodCube's Ohm answer](https://codegolf.stackexchange.com/a/129569/47066)
```
;îxsc
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f@vC6iuLk///NAQ "05AB1E – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly)
```
HĊµḤc
```
A monadic link, taking a (0-indexed) row and returning the middle number or the sum of the two middle numbers - equivalently the middle number of the row beneath).
[Try it online!](https://tio.run/##y0rNyan8/9/jSNehrQ93LEn@//@/oQEA "Jelly – Try It Online"), or see the first 20 values in the [test suite](https://tio.run/##ASEA3v9qZWxsef//SMSKwrXhuKRj/zIw4bi2wrXFvMOH4oKsR/8 "Jelly test suite – Try It Online").
### How?
```
HĊµḤc - Link: number v
H - halve = v/2
Ċ - ceiling, i.e. (v + isOdd?(v)) / 2
µ - monadic chain separation, call that k
Ḥ - double k (this is n: v if v was even, or v+1 if v was odd)
c - that choose k = nCk, the required result
```
[Answer]
# [R](https://www.r-project.org/), 35 bytes
```
function(n)(1+n%%2)*choose(n,n%/%2)
```
An anonymous function.
Since odd rows need to be doubled, `n%%2+1` is 2 when `n` is odd and `1` when `n`n is even. Then, I multiply by the appropriate binomial coefficient.
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP08jT1PDUDtPVdVIUys5Iz@/OFUjTydPVR/I/5@mYaLJlaZhqvkfAA "R – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~88~~ ~~81~~ ~~80~~ ~~79~~ ~~74~~ 72 bytes
Thanks to @JonathanAllen
```
import math
f=math.factorial
n=input()
print(n%2+1)*f(n)/f(n/2)/f(n-n/2)
```
[Try it online!](https://tio.run/##HcZNCoAgEEDh/ZyiTTBTlCS09DASDIo5ikyLTm8/m/e@emsoYnuPuZamQ/YagN23lf2hpUV/grgo9VIkSK8UxViC2n6Odt5oYhQyjOmLLIl63x8 "Python 2 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~40~~ 38 bytes
```
f=lambda n:n<1or(-n|1)*2*f(n-2)/(-n/2)
```
[Try it online!](https://tio.run/##DcpLCoAgFEbheau4Q68kPoZSizHKEupXxEnQ3s0z@@CUt10Zrve43uHZ9kDwWGyuQuGzLJ2MAsqxHtaOe8yVQAlUA85DWGPYTzQqNaERZho/9x8 "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
c:2$×Ḃ‘$
```
[Try it online!](https://tio.run/##y0rNyan8/z/Zykjl8PSHO5oeNcxQ@f//vwkA "Jelly – Try It Online")
[Answer]
# Dyalog APL, 12 bytes
```
{k!2×k←⌈⍵÷2}
```
or
```
(⊢!2∘×)∘⌈÷∘2
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhOpsRaPD07OBrEc9HY96tx7eblQLlFEw4UpTMAUA)
**How?**
`⍵÷2` - divide by 2
`⌈` - ceiling
`k←` - assign to `k`
`2×` - double
`k!` - binomial with `k`
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/99949/edit).
Closed 3 years ago.
[Improve this question](/posts/99949/edit)
There is a helicopter flying **500** meters from the ground. It can fly up **100** meters, which takes **1.0 secs**. Or if it doesn't fly up it will fall 200 meters, which also takes **1.0 secs** - This means if the instruction is **anything** other than "Fly" the helicopter falls. Build a program that takes input of a list of instructions, telling the helicopter when to fly and when not to. **When the helicopter falls it should output the time counter**.
INPUT:
>
> Fly Dance Fly Golf Fly Fly
>
>
>
OUTPUT:
>
> 8.5 secs
>
>
>
Walkthrough:
>
> 1) Fly == Fly so +100 = 600m
>
>
> 2) Dance != Fly so -200 = 400m
>
>
> 3) Fly == Fly so +100 = 500m
>
>
> 4) Golf != Fly so -200m = 300m
>
>
> 5) Fly == Fly so +100 = 400m
>
>
> 6) Fly == Fly so +100 = 500m
>
>
> 7) NO INSTRUCTIONS so -200 = 300m
>
>
> 8) NO INSTRUCTIONS so -200 = 100m
>
>
> 9) NO INSTRUCTIONS so -100 = 0m (This takes 0.5 seconds)
>
>
>
Each instruction should be separated by a space, and if the instuction isn't fly, then automatically fall. When the program runs out of instructions automatically fall. Your program **must** output in (float)secs, and if it takes => 60.0 seconds display in mins and seconds eg. 1 mins 32.0 secs
Seconds are float **decimal** values, minutes are whole interger values. Also note capitalization does **not** matter your program should work for capitals or no capitals.
This is code-golf so the least NO bytes wins!
[Answer]
# Python, ~~100~~ ~~92~~ 89 bytes
```
lambda I:sum(reduce(lambda(a,s),i:(a+(a>0)*(-1,.5)[i=='Fly'],s+(a>0)),I.split(),(2.5,0)))
```
[try it online](https://tio.run/##ZYxBDoIwEEX3nmKCC6ZaiZKwIcGV0XAGdVGglSalJW1ZcPqKIRGiiz/Jf5P/@tG3RqdBFI@gWFc1DMrcDR1a3gw1x5kho45QmSPbIzsfyQ4PJ5pk5C6LIr6qMX5SN38ILRPXK@mRUEyTjE6IhN5K7VFgFBGy@ZYL0zX/J7C@k/w30wK2UFvmWqi4MJaDt6PUL/AGhBoX3WewaG5GiZUjvAE)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 31 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
l#ā«'¤†Q3*Í5šηO.γd}нRć;sg+60‰0Û
```
Follows the challenge to the letter. Input as a space-delimited string, and output as a list `[sec]` or `[min,sec]`, where `sec` is a float and the potential `min` is an integer.
If taking the input as a list of strings is allowed, the `#` could be removed.
If outputting as `[min,sec]` even if `min` is 0 is allowed, the tailing `0Û` can be removed.
[Try it online](https://tio.run/##yy9OTMpM/f8/R/lI46HV6oeWPGpYEGisdbjX9OjCc9v99c5tTqm9sDfoSLt1cbq2mcGjhg0Gh2f//@@WU6ngkpiXnKoAYrnn56SBGUAMAA) or [verify a few more test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/HOUjjYdWqx9a8qhhQaCx1uFe06MLz2331zu3OaX2wt6gI@3WxenaZgaPGjYYHJ79X@d/tJJbTqWCS2JecqoCiOWen5Om4OYTqZDmU6mko6AEkUEmQarQMEghCIP1gYRQabBUTmVmXjqIB6WgTJAclDeKR/EoHsY4MS9FobgksahEIS0xJwdUDuTllyvFAgA).
**Explanation:**
```
l # Convert the (implicit) input-string to lowercase
# i.e. "Fly Dance Fly Golf FLY fLy"
# → "fly dance fly golf fly fly"
# # Split it on spaces
# → ["fly","dance","fly","golf","fly","fly"]
ā # Push a list in the range [1, length]
# (without popping the list itself)
# → [1,2,3,4,5,6]
« # Merge it to the list of words
# → ["fly","dance","fly","golf","fly","fly",1,2,3,4,5,6]
'¤† '# Push dictionary string "fly"
Q # Check for each word (or integer) if it's equal to "fly"
# (1 if truthy; 0 if falsey)
# → [1,0,1,0,1,1,0,0,0,0,0,0]
3* # Multiply each by 3
# → [3,0,3,0,3,3,0,0,0,0,0,0]
Í # Decrease each by 2 (so 1 if truthy; -2 if falsey)
# → [1,-2,1,-2,1,1,-2,-2,-2,-2,-2,-2]
5š # Prepend a 5 to this list
# → [5,1,-2,1,-2,1,1,-2,-2,-2,-2,-2,-2]
η # Get all prefixes of this list
# → [[5],[5,1],...[[5,1,-2,1,-2,1,1,-2,-2,-2,-2,-2,-2]]
O # Sum each prefix
# → [5,6,4,5,3,4,5,3,1,-1,-3,-5,-7]
.γ } # Consecutive group the values by:
d # Where the value is >= 0
# → [[5,6,4,5,3,4,5,3,1],[-1,-3,-5,-7]]
}н # After the group-by, only leave the first group
# → [5,6,4,5,3,4,5,3,1]
Rć # Reverse and extract the head,
# so we've extracted the last item loose to the stack
# → [3,5,4,3,5,4,6,5] and 1
; # Halve that last item
# → [3,5,4,3,5,4,6,5] and 0.5
sg # Swap to get the list, and pop and push its length
# → 8
+ # Add it to the halved last item
# → 8.5
60‰ # Take the divmod-60
# → [0,8.5]
0Û # And remove a potential leading 0
# → [8.5]
# (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `'¤†` is `"fly"`.
[Answer]
# Perl, 90 bytes
```
$a=5;
$_++,$a+=shift=~/Fly/?1:-2 while$a;
$==$_/60;
$_%=60;
say+($=?"$= mins ":"")."$_ secs"
```
Accepts input as command-line parameters. Run as
```
perl -E '$a=5;$_++,$a+=shift=~/Fly/?1:-2 while$a>0;$==$_/60;$_%=60;say+($=?"$= mins ":" ")."$_ secs"' Fly Dance Fly Fly Golf
```
Starts `$a` at 5, and increases it by 1 every time it finds "Fly", decrements by 2 otherwise. Keeps going until `$a` is non-positive, and counts how many iterations it took to get there. `$=` is special and forces its value to be an integer, so `$==$_/60` only takes the integer portion of the division, ignoring the rest. Everything else is self-explanatory, I feel.
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 64 bytes
```
wdm{"Fly"=={1}{-2}IE}@5+]q++pa{0.>}TWsa-.j[~2./.+J60./foJ60.*j.-
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/PCW3Wsktp1LJ1rbasLZa16jW07XWwVQ7tlBbuyCx2kDPrjYkvDhRVy8rus5IT19P28vMQE8/LR9EaWXp6f7/D9Ss4JKYl5yqAGK55@ekgRlQDAA "Burlesque – Try It Online")
```
wd # Split into words
m{ # Map
"Fly"== # word is "Fly"?
{1}{-2}IE # If fly 1 else -2
}
@5+] # Prepend 5.0
q++pa # Calculate partial sums
{0.>}TW # Take until 0 or less
sa-. # Length of this -1 (to account for pushed 5.0)
j[~2./ # Take the remaining height /2
.+ # Add this time
############ Mins Secs ##############
J60./fo # Calc number of mins
J60.* # N mins * 60
j.- # Calc seconds over
```
If we don't have to deal with the mins/secs rule:
# Burlesque, 49 bytes
```
wdm{"Fly"=={1}{-2}IE}@5+]q++pa{0.>}TWsa-.j[~2./.+
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/PCW3Wsktp1LJ1rbasLZa16jW07XWwVQ7tlBbuyCx2kDPrjYkvDhRVy8rus5IT19P@/9/oGoFl8S85FQFEMs9PycNzIBiAA "Burlesque – Try It Online")
[Answer]
# C 93
**Thanks to @ceilingcat for finding a ***much*** shorter version**
```
i,h=5;main(c,v)int**v;{for(;h>0;)h+=*v[(++i<c)*i]-'ylF'?-2:1;printf("%f secs\n",i-(h<0)*.5);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9TJ8PW1Do3MTNPI1mnTDMzr0RLq8y6Oi2/SMM6w87AWjND21arLFpDWzvTJllTKzNWV70yx03dXtfIytC6oAioPk1DSTVNoTg1uTgmT0knU1cjw8ZAU0vPVNO69v///245lf9dEvOSU8Es9/ycNDADiAE "C (gcc) – Try It Online")
[Answer]
# PHP, ~~55~~ 54 bytes
```
for($h=5;$h>0;)$h+='Fly'==$argv[++$i]?:-2;echo$h/2+$i;
```
Loops through command line arguments; run with `-r`.
Height is divided by 100 to simplify output and calculation: If height is below zero (i.e. -100m),
adding half of it (-50 divided by 100: -.5) to the time removes half a second from the result.
That combined with the magic of Elvis golfed ~~5~~ 6 bytes from my initial program.
[Answer]
## Mathematica 211 bytes
```
(s=ToString;t=Length[#[[;;(FirstPosition[#,x_/;x<=0,1]-1/. 0->Length@#)]]]&[x=500+Accumulate[If[#=="Fly",100,-200]&/@(StringSplit@#)]];
If[#>=60,s@Floor[#/60]~~" min ",""]~~s@Mod[#,60]~~ " sec"&[t+x[[t]]/200.])&
```
This algorithm assumes the flight ends when the altitude reaches 0 for the first time. Looking at some of the other answers, I think people have the helicopter flying below ground level. I don't allow "touch and go" either.
Ungolfed:
```
in="Fly Dance Fly Golf Fly Fly";
s=ToString;StringSplit@in
If[#=="Fly",100,-200]&/@%
altList=500+Accumulate@%
l=Length@altList
(* find last positive before first nonpositive *)
FirstPosition[altList,x_/;x<=0,1]-1
t=Length[altList[[;;(%/. 0->l)]]]
t+altList[[t]]/200.
If[%>=60,s@Floor[%/60]~~" min ",""]~~s@Mod[%,60]~~ " sec"
```
[Answer]
# Javascript, 137
```
a=>{for(s=5,i=0,a=a.toLowerCase().split(" ");s>=0;){s+=a[i]&&a[i++]=="fly"?1:-2}return parseInt(i/60)+"min "+(i%60+s/2).toFixed(1)+"sec"}
```
[Try it online!](https://tio.run/##hY7dasMwDIVfxRhWbNykaWG9WHF3MQgM8gJl9EJN7MzDs4PlLCulz56ZsR9C93PxCSEdnaMneAGsg@lidoCDspnzjRq1HEFuT9oHhvJ6bmQxBwl59JUfVLgDVIzn2FkTGSWUb3Ariw0/oZDwYPazWapC7KWk2h7p7fImW52Din1wpIOA6t5FZhbrggv6bByhgpmrdSFwseIpozSvqmHLtERV0/NYe4feqtz6lmlGS3sk@g8eDYkKY@r7r9nPN/07ZbX7R/dNA65WBFpIXzs/XGqqS/@p7@6D6V3rJ/LfGFLsp4ZyPr4B)
Test:
```
"Fly fly fly fly fly fly fly fly hi test flu fly fly Fly fly fly fly fly flu flu FLY fly fly Fly fly fly fly fly fly fly fly dance again now fly fly fly fly fLy fly fly flu flu fly Fly fly flY flY fly fly fly fly go flu flu fly fly fly fly fly fly fly win flu fly "
```
Result:
```
1min 17.5sec
```
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 80 bytes
Caveat: case sensitive.
This will return (minutes, seconds) if the flight takes more than 59 seconds, otherwise – only seconds.
```
{(1+⍵≥60)⌷⍵(⍵(⌊÷,⊢|⊣)60)},{(⍵⍳0)⌊¯0.5+⍵⍳¯1}{5++\¯2@~(4×≢⍵)↑{⍵≡'Fly'}¨' '(≠⊆⊢),⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhGoNQ@1HvVsfdS41M9B81LMdyNYA456uw9t1HnUtqnnUtVgTKFerUw2SeNS7GaSu69B6Az1TbYjAofWGtdWm2toxh9YbOdRpmBye/qhzEVBK81HbxGqw4QvV3XIq1WsPrVBXUNd41LngUVcb0GhNHaBkLdAdCuqO6lxAEqQISiu4JOYlpyqAWO75OWlgBkzaNbFEISAnsVLBJ78sFSaDjuEGDVYM9qA6AA "APL (Dyalog Classic) – Try It Online")
Without conversion to minutes it's 54 bytes:
```
{(⍵⍳0)⌊¯0.5+⍵⍳¯1}{5++\¯2@~(4×≢⍵)↑{⍵≡'Fly'}¨' '(≠⊆⊢),⍵}
```
[Answer]
# Scala, 88 bytes
```
s=>{val n=s.split(" ").count("Fly"==)*1.5+2.5
(if(n<60)""else n/60+"min ")+n%60+" secs"}
```
Ungolfed:
```
s=>{
val n=s.split(" ").count("Fly"==)*1.5+2.5
(
if(n<60)
""
else
(n/60)+"min "
)
+(n%60)
+" secs"
}
```
Uses the same formula as [Copper's python answer](https://codegolf.stackexchange.com/a/100110/46901).
[Answer]
# Python 2, ~~85~~ 91 bytes
```
t=2.5+input().upper().split().count('FLY')*1.5
print('%d mins'%(t/60))*(t>59),`t%60`,'secs'
```
Takes input on STDIN, surrounded by quotes (single or double). Simply counts the number of `Fly`s there are in the input, performs some path to calculate the number of seconds, then formats it.
Now case-insensitive!
*Fixed a bug with the same bytecount thanks to Jonathan Allan!*
*Saved 2 bytes thanks to Shebang!*
[Answer]
# AWK, 150 bytes
Below is a rather straightforward implementation in AWK,
the nice thing about it is that you can run it interactively and
feed it by typing commands by hand (just don't forget to remove RS=" ", if you want one command per line).
**Golfed**
```
awk 'BEGIN{RS=" ";h=500;t=0}toupper($0)~/FLY/{h+=100;t+=1;next}{h-=200;t+=1;}END{t+=h/200;F=(t>59?"%d mins ":"%.0d") "%.1f secs";printf F,t/60,t%60;}'
```
**Test**
```
echo "Fly Dance FLy Golf Fly Fly" |\
awk 'BEGIN{RS=" ";h=500;t=0}toupper($0)~/FLY/{h+=100;t+=1;next}{h-=200;t+=1;}END{t+=h/200;F=(t>59?"%d mins ":"%.0d") "%.1f secs";printf F,t/60,t%60;}'
8.5 secs
```
] |
[Question]
[
1. Your sourcecode **must not** contain any of the characters it outputs (case sensitive).
2. Your program **must not** output more than 500 characters/bytes. 1 byte = 1 char. Newline counts as 1 character.
3. Your program should **not** take any input. (from user, filename, network or anything).
4. Your program must output words/phrases worth a total of **minimum 700 points** according to the following score table (case sensitive):
*Score table:*
```
me - 2 points
ore - 3 points
freq - 5 points
pager - 7 points
mentor - 11 points
triumph - 13 points
equipage - 17 points
equipment - 19 points
equivalent - 23 points
equilibrium - 29 points
unubiquitous - 31 points
questionnaire - 37 points
Mutüal 3xcLUs1ve_Equino>< - 400 points
```
* 4.1 Each word can be repeated but lose 1 point for each repetition (with exception for the last phrase worth 400 points, you **must not** repeat that in the output). For example:
four of `equilibrium` (in any place) in the output = `29+28+27+26` points.
* 4.2 Letters in the output can be used in more than one word, for example:
`equipager` = `equipage` and `pager` = `17+7` points.
This is code-golf, shortest sourcecode in bytes wins! Good luck, have fun!
[Answer]
# Golfscript, 24 characters
```
"QUESTIONNAIRE"{32+}%36*
```
Way too easy.
36 repetitions of "questionnaire" = 36\*13 characters = 468 characters.
36 repetitions of "questionnaire" = 37+36+...1 point = (37+1)(37)/2 points = 703 points.
[Answer]
## JavaScript, 391 chars
Could be golfed further. Port of Jan Dvorak's answer; alerts `"questionnaire"` 36 times (although, hardcoded instead of via a loop). `T` contains the string "true", `F` the string "false" and `O` the string "[object Object]". From these (and `(1/0)+[]` = "Infinity"), `R` = "return" and `C` = "constructor" are constructed. From this, we create a function `$` that does `alert("QUESTIONNAIRE"["toLowerCase"]())` and invoke it 36 times.
```
T=!![]+[]
F=![]+[]
O={}+[]
R=T[1]+T[3]+T[0]+T[2]+T[1]+(0[[]]+[])[1]
C=O[5]+O[1]+(0[[]]+[])[1]+F[3]+T[0]+T[1]+T[2]+O[5]+T[0]+O[1]+T[1]
$=0[C][C](_[F[1]+F[2]+T[3]+T[1]+T[0]]+'("QUESTIONNAIRE"[T[0]+O[1]+"L"+O[1]+"w"+T[3]+T[1]+"C"+F[1]+F[3]+F[4]]())')
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()
$();$();$();$();$();$()
```
[Answer]
## Perl 6 (33 chars)
```
EVAL "SAY 'QUESTIONNAIRE'x 35".lc
```
13 chars \* 35 repetitions = 455 chars total output
+ == 700 points; (3..37).elems = 35 repetitions.
[Answer]
## JavaScript (88342)
<http://pastebin.com/6UNTNXeT>
alerts **Mutüal 3xcLUs1ve\_Equino><** once + **unubiquitous** 12 times
Score: 706
[Answer]
# C64 BASIC, 64 PETSCII chars
Should output 13 times the string "questionnaireunubiquitousequilibrium", with a score of:
equilibrium = 29+28+27+26+25+24+23+22+21+20+19+18+17=299
unubiquitous = 31+30+29+28+27+26+25+24+23+22+21+20+19=325
**1027**.
(output is **481** chars long)
] |
[Question]
[
**This question already has answers here**:
[Print/Output the L-phabet](/questions/87064/print-output-the-l-phabet)
(128 answers)
Closed 1 year ago.
The community reviewed whether to reopen this question 1 year ago and left it closed:
>
> Original close reason(s) were not resolved
>
>
>
For the given string `s`, generate generate a table like below.
```
Input:abcd
Output:
abcd
bbcd
cccd
dddd
Input:Hello, world!
Output:
Hello, world!
eello, world!
llllo, world!
llllo, world!
ooooo, world!
,,,,,, world!
world!
wwwwwwwworld!
ooooooooorld!
rrrrrrrrrrld!
llllllllllld!
dddddddddddd!
!!!!!!!!!!!!!
```
Trailing whitespace allowed.
This is a code-golf challenge so the shortest solution wins.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 12 bytes
Anonymous prefix lambda.
```
{⍵[∘.⌈⍨⍳≢⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR79boRx0z9B71dDzqXfGod/OjzkVAsdja/2mP2iY86u171NX8qHfNo94th9YbP2qb@KhvanCQM5AM8fAM/p@moJ6YlJyizgVkeKTm5OSX6yiU5xflpCiqAwA "APL (Dyalog Unicode) – Try It Online")
`{`…`}` "dfn"; argument is `⍵`
`⍵[`…`]` index into characters using the array:
`≢⍵` tally of characters
`⍳` indices of array of that length
`∘.⌈⍨` maximum-table using that both going down and across
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 9 bytes[SBCS](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn)
Tacit prefix port of [my APL answer](https://codegolf.stackexchange.com/a/243945/43319)
```
⌈⌜˜∘↕∘≠⊸⊏
```
`⌈` maximum-
`⌜` table
`˜` of self
`∘` of
`↕` the indices
`∘`
`≠` the string length
`⊸⊏` selects characters from that tring
[Run online!](https://mlochbaum.github.io/BQN/try.html#code=RuKGkOKMiOKMnMuc4oiY4oaV4oiY4omg4oq44oqPCkbCqCJhYmNkIuKAvyJIZWxsbywgd29ybGQhIg==)
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 12 bytes
```
{x@i|\i:!#x}
```
[Try it online!](https://ngn.codeberg.page/k#eJyFkbFugzAURff3FYZ2SKQQSy1LYenYTv2ANFKMMWDFxaltFKI0/fbGBBCPDL3T9ZGfDcdFcm5f5c+nTIKH9gLgkvPj5vRrkoIQ0qY7vU8Xu4JJlbbpKTXL7QXcJmQZz0Mgi6GQMBsK59dCfMuvCZdb8ANvQim9IkdtVB50k3NCQnFHlPqfaB9EVl2mhNwyIcc+s3N8RmLGTG/v05N8khsJpul+n0Ll3MEmlHKdi1KrYm0d43vR8orVpVhz/UW/G2Gd1LWlT/HzSxzTUtTCMCciV0kbWWdkXUaOZUoAvNeHxiXePXw0znfoFv4RwD8A+O8Z9iHT4wCmyD0gy7MV8g3INSDPgBwD8gvILSCvgJwC8vkHcHHRzQ==)
A port of [@Adám's APL answer](https://codegolf.stackexchange.com/a/243945/98547), using a trick with a seeded scan instead of an each-right or each-left.
* `i:!#x` generate list of indices of the input `x`, storing in `i`
* `i|\i` set up a scan, seeded with `i`, run over each value in `i`. this is equivalent to, but one byte shorter, than `i|/:i` or `i|\:i`
* `x@` index back into the input, implicitly returning
[Answer]
# [Python 3](https://docs.python.org/3/), 45 bytes
```
lambda s:[s[l]*l+s[l:]for l in range(len(s))]
```
[Try it online!](https://tio.run/##TY7NCsIwEITvfYo1l/zYXvQWqGffofaQ2kQLa1KSBRHx2WPTgjiXZYf5dmd@0T34Y3btJaN5DKOBpLvUYa9wvwzduxABYfIQjb9ZgdaLJGWfySZK0IJgZriOrAZ2toihhmeIOO6YrApJhVyjuoJFc5w8CcfZmz4MmhNwufrlkhO0Lb@XSW95lH8wb7gqLUiqg8xf "Python 3 – Try It Online")
Inputs a string.
Returns a list of strings.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 42 bytes
```
->s{r=0;s.chars.map{|c|s[0,r+=1]=c*r;s.b}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1664usjWwLpYLzkjsahYLzexoLomuaY42kCnSNvWMNY2WasIKJlUW/u/oLSkWCEtWskxL0UhUSG5KjU5QyE/L1WhJD9fKfY/AA "Ruby – Try It Online")
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/194304/edit).
Closed 4 years ago.
[Improve this question](/posts/194304/edit)
Write a program which, when every nth character is skipped, it prints n. For example, if every 2nd character is skipped, it prints 2.
# Example
**n=0**
```
foobar
```
Output:
```
0
```
**n=1**
```
foa
```
Output:
```
1
```
**n=2**
```
fobr
```
Output:
```
2
```
# Rules
* If n=0 (no characters are skipped), 0 must be returned.
* Must print to STDOUT.
* Standard loopholes are forbidden.
* The first character is never skipped.
* Obviously, it doesn't need to work for more characters than the code has (e.g. if your code is 11 characters long, it doesn't need to work for every 11th character)
# Scoring
This is *code golf*, so the shortest code in bytes wins.
[Answer]
# Polyglot, 1 byte
```
0
```
[Try it in Retina](https://tio.run/##K0otycxL/P/f4P9/AA "Retina 0.8.2 – Try It Online")
[Try it in Jelly](https://tio.run/##y0rNyan8/9/g/38A "Jelly – Try It Online")
[Try it in 05AB1E](https://tio.run/##yy9OTMpM/f/f4P9/AA "05AB1E – Try It Online")
[Try it in Husk](https://tio.run/##yygtzv7/3@D/fwA "Husk – Try It Online")
[Try it in ///](https://tio.run/##K85JLM5ILf7/3@D/fwA "/// – Try It Online")
[Try it in GolfScript](https://tio.run/##S8/PSStOLsosKPn/3@D/fwA "GolfScript – Try It Online")
[Try it in BrainGolf](https://tio.run/##SypKzMxLz89J@//f4P9/AA "Braingolf – Try It Online")
[Try it in Pyth](https://tio.run/##K6gsyfj/3@D/fwA "Pyth – Try It Online")
[Try it in Japt](https://tio.run/##y0osKPn/3@D/fwA "Japt – Try It Online")
[Try it in ink](https://tio.run/##y8zL/v/f4P9/AA "ink – Try It Online")
[Try it in PHP](https://tio.run/##K8go@P/f4P9/AA "PHP – Try It Online")
[Try it in Brachylog](https://tio.run/##SypKTM6ozMlPN/r/3@D///9RAA "Brachylog – Try It Online")
[Try it in MATL](https://tio.run/##y00syfn/3@D/fwA "MATL – Try It Online")
[Try it in Keg](https://tio.run/##y05N///f4P9/AA "Keg – Try It Online")
[Try it in Carrot](https://tio.run/##S04sKsov@f/f4P9/AA "Carrot – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[pssssssssssssst](/questions/95318/pssssssssssssst)
(7 answers)
Closed 6 years ago.
Given a positive integer N, output the innermost N×N square of an ASCII art spiral made of `-|/\` that spirals clockwise inward.
The `-` is used for horizontal portions, `|` for vertical portions, and `/` and `\` for corners. The first character is `-` and the spiral proceeds left and down.
Specifically, when N is 1 the output is:
```
-
```
When N is 2 the output is:
```
/-
\-
```
When N is 3 the output is:
```
--\
/-|
\-/
```
When N is 4 the output is:
```
/--\
|/-|
|\-/
\---
```
Note how every output is a square of N by N characters.
The pattern continues in the same way:
```
N=1
-
N=2
/-
\-
N=3
--\
/-|
\-/
N=4
/--\
|/-|
|\-/
\---
N=5
----\
/--\|
|/-||
|\-/|
\---/
N=6
/----\
|/--\|
||/-||
||\-/|
|\---/
\-----
N=7
------\
/----\|
|/--\||
||/-|||
||\-/||
|\---/|
\-----/
N=8
/------\
|/----\|
||/--\||
|||/-|||
|||\-/||
||\---/|
|\-----/
\-------
etc.
```
The shortest code in bytes wins.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~17~~ 16 bytes:
```
↶⁴-Ｆ⊖Ｎ«↶²/ι↶²\-ι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8gsyy/xCc1rUTDRNOaK6AoM69EQ0lXCchOyy9S0HBJTS5KzU3NK0lN0fDMKygt8SvNTUot0tDU1FSo5uJE6DYC6uCEatdXQnAywUysymJidNEU1v7/b/pft@y/bnEOAA "Charcoal – Try It Online") Link is to verbose version of code.
```
↷²-¶Ｆ⊖Ｎ«/ι↶²\-ι↶
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8gsyy/JCgzPaNEw0jTmiugKDOvRENJNyZPCchLyy9S0HBJTS5KzU3NK0lN0fDMKygt8SvNTUot0tDU1FSo5uKE6tAHqYdyMsFMkME@qWkQc2HKYmJ0cSsE8mr//zf9r1v2X7c4BwA "Charcoal – Try It Online") Link is to verbose version of code.
Edit: Saved 1 byte thanks to @icrieverytim.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~148~~ 134 bytes
```
f=lambda n,J=''.join:n<2and['-']or n%2and['-'*~-n+'\\']+map(J,zip(f(n-1),'|'*(n-2)+'/'))or map(J,zip('/'+'|'*n,f(n-1)))+['\\'+'-'*~-n]
```
[Try it online!](https://tio.run/##RY7BDoIwDIbP7il2MV3Z0DD1QuTKgVcADjNIwEhZCBeN8dXnFiBevrR///6tfc3dSNq5Nnua4dYYTqrIAA6PsaeUrtpQU0IM9Thx2m9d9I1JQlVBLQdjRaHevRWtoDhBBR@IfKVRwhEQ/d7f4hUZ5qQWM6IsQ4xcM2vX3FueC8KU7ezU08xpK6Ci5atwCHGVGctFgh464BRwDrggcz8 "Python 2 – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[We're no strangers to code golf, you know the rules, and so do I](/questions/6043/were-no-strangers-to-code-golf-you-know-the-rules-and-so-do-i)
(73 answers)
Closed 6 years ago.
**To-Do: Come up with a Better Title**
---
### Specification:
This challenge is similar to [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'"), but with a twist. You goal is to output a finite string that resembles the following string of psuedo-random characters as closely as possible:
```
BABBBBAAABBAABBBBAABBBAABBBABBAABABABBBBABBBBBBAABABBAABABBBABBBABAAAAABAAAABBAAABAAABBBBAABBABBBAABBBAABAAAABAAAABABABBBBBAABAAABBABAABAABABABBAABAAABBBABBABABBABAABABABBAABBBAABABABBBABAAABAABBBBBAABBBABABAABAABBAABABBBAABBAABAAABABABBBBBAAAAABBBAAABABAABBAABAABAAAABABBBAABBABBBBBAABAAAAABABBBAAAAAABAAAABBABAABABBAAABBBBBBAABABBAAAAAABABBAAABBABBABBBBAAAAAABABBBBBABBBABBAABBABAABAAAAABBAABABBABAABABABBBAAAAAABBBBBABABBBBBAABAABBBAAABABBABBAAABBABBABABBAABBAABAABBBABBABABBABABABABABBBAAABBBBBBABAAAAAABBAABBAABBBAAAAAAABBBBABBBBAABAABAABBABBAAAAAABABBABAAAAABABABAABAABBBAABBABAAABABAAAAABAABABAABBABAABBABBABAABABBBBAAAAAABAAAAAAAAABAABAAAAAAAABABAABBBABAAABABBBBBAAABAAAABBBBBABBBAAAAABBBABBAAAABAABBBBAABBABABAAABAABAAAAABBABBBABBBBAABBABABBAABAAAABAABBABABBBAABABABABAABAAAAABBABBBABBABBAAABAAAABBABABBBABBABABBBBABAAABBBBAAAABBABAAABABBBBBABABBAABBABAAABBABAAAAAABBBAAAABBBAAABABAAAAABBBBABAAABBBAAAABABBBBAAAAABBBBAABAABABBABABBABAAAABBBBAAABAABAAABBBBBBABBABAABABAABBBBBBBBAABBBAABAABABAABBAAABABAABAABBBBBBABBA
```
The string is 1024 characters long, and consists only of uppercase `A` and `B` characters. You must write a program takes up less than or equal to 256 bytes. The above string was generated completely randomly.
This challenge is **not** code-golf! Since 256 bytes is far too few characters (even for golfing languages), you may output any finite string. Your score is Levenshtein Distance between the 1024 byte string, and the string your program outputs (where the lower score is the best.)
---
### Examples:
```
Input, Output
1024 "A" characters, 500 Points
1024 "B" characters, 524 Points
1024 characters alternating between "A" and "B" ("A" first), 348 Points
1024 characters alternating between "A" and "B" ("B" first), 346 Points
```
---
### Notes:
* The output must be finite and deterministic.
* Unfortunately, this challenge is limited to languages that can be scored in bytes.
* You may not substitute `A` and `B` for other characters. If your language cannot output such characters, it may not compete.
* If a language cannot compete, it is still welcome to post non-competing answers. Just make sure to explain how you are scoring the challenge.
* The winner of this challenge is on a **per-language basis**, since would be unlikely that an answer from Brainf\*\*\* would ever beat one from Jelly.
[Answer]
# PHP, 246 printable bytes, distance 0
```
while($c=ord(base64_decode("vGec7K9+WXdBDEebnIQr5GkrI7WlZyuifOpMuZFfBxTJC5vkFwIaWPywLG3gX3ZpBlpXA+vk4tjazJ2tVcfoGZwHvJNgWgqTmiglNNpeBAEgFOi+IfcHYTzUSDd5rITXKpBu2Ia7Xo8NF9Zo0DhxQejheDyWtDxI/aU/zkpik/Y")[$i++]))echo strtr(sprintf("%08b",$c),10,BA);
```
or
```
while($c=base64_decode("vGec7K9+WXdBDEebnIQr5GkrI7WlZyuifOpMuZFfBxTJC5vkFwIaWPywLG3gX3ZpBlpXA+vk4tjazJ2tVcfoGZwHvJNgWgqTmiglNNpeBAEgFOi+IfcHYTzUSDd5rITXKpBu2Ia7Xo8NF9Zo0DhxQejheDyWtDxI/aU/zkpik/Y")[$i++])echo strtr(sprintf("%08b",ord($c)),10,BA);
```
Remarkable: gnuzip fails on the binary string. `gzcompress` adds 11 bytes and `gzdeflate` adds 5.
The fact that no `0x00` byte is in there saves 2 bytes on the first version;
no `0x30` saves 2 bytes on the second one.
[Answer]
# Pyth, distance 0
```
."AB¼gì¯~YwA
G+äi+#µ¥g+¢|êL¹_É
äXü°,mà_viZWëäâØÚÌUÇè¼`Z
(%4Ú^ è¾!÷a<ÔH7y¬×*nØ»^
ÖhÐ8qAèáx<´<Hý¥?ÎJbö"
```
The code is 135 Bytes long
[Answer]
# JavaScript (ES6), distance 0
```
alert("¼gì¯~YwAG+äi+#µ¥g+¢|êL¹_ÉäXü°,mà_viZWëäâØÚÌUÇè¼`Z\n(%4Ú^ è¾!÷a<ÔH7y¬×*nØ»^\rÖhÐ8qAèáx<´<Hý¥?ÎJbö".replace(/[^]/g,c=>("0000000"+c.charCodeAt().toString(2)).slice(-8).replace(/./g,x=>"AB"[x])))
```
Contains lots of unprintables, so get the real code from [this pastebin](https://pastebin.com/VzadqKxP). The code is 232 bytes long.
[Answer]
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), distance 283, 45 bytes
```
-[+[>+<<]>+]>[>++>+<<-]>[>+.+.-.+..-.+.-.-<-]
```
[Try it online!](https://tio.run/nexus/brainfuck#@68brR1tp21jE2unHWsHZGmDOLpgpp62ni4QgwldPV2g6P//AA "brainfuck – TIO Nexus")
# [brainfuck](https://github.com/TryItOnline/tio-transpilers), distance 0 (non-competing)
Non-competing due to length (1548).
```
>+[+[<]>>+<+]>+.-.+....-...+..-..+....-..+...-..+...-.+..-..+.-.+.-.+....-.+......-..+.-.+..-..+.-.+...-.+...-.+.-.....+.-....+..-...+.-...+....-..+..-.+...-..+...-..+.-....+.-....+.-.+.-.+.....-..+.-...+..-.+.-..+.-..+.-.+.-.+..-..+.-...+...-.+..-.+.-.+..-.+.-..+.-.+.-.+..-..+...-..+.-.+.-.+...-.+.-...+.-..+.....-..+...-.+.-.+.-..+.-..+..-..+.-.+...-..+..-..+.-...+.-.+.-.+.....-.....+...-...+.-.+.-..+..-..+.-..+.-....+.-.+...-..+..-.+.....-..+.-.....+.-.+...-......+.-....+..-.+.-..+.-.+..-...+......-..+.-.+..-......+.-.+..-...+..-.+..-.+....-......+.-.+.....-.+...-.+..-..+..-.+.-..+.-.....+..-..+.-.+..-.+.-..+.-.+.-.+...-......+.....-.+.-.+.....-..+.-..+...-...+.-.+..-.+..-...+..-.+..-.+.-.+..-..+..-..+.-..+...-.+..-.+.-.+..-.+.-.+.-.+.-.+.-.+...-...+......-.+.-......+..-..+..-..+...-.......+....-.+....-..+.-..+.-..+..-.+..-......+.-.+..-.+.-.....+.-.+.-.+.-..+.-..+...-..+..-.+.-...+.-.+.-.....+.-..+.-.+.-..+..-.+.-..+..-.+..-.+.-..+.-.+....-......+.-.........+.-..+.-........+.-.+.-..+...-.+.-...+.-.+.....-...+.-....+.....-.+...-.....+...-.+..-....+.-..+....-..+..-.+.-.+.-...+.-..+.-.....+..-.+...-.+....-..+..-.+.-.+..-..+.-....+.-..+..-.+.-.+...-..+.-.+.-.+.-.+.-..+.-.....+..-.+...-.+..-.+..-...+.-....+..-.+.-.+...-.+..-.+.-.+....-.+.-...+....-....+..-.+.-...+.-.+.....-.+.-.+..-..+..-.+.-...+..-.+.-......+...-....+...-...+.-.+.-.....+....-.+.-...+...-....+.-.+....-.....+....-..+.-..+.-.+..-.+.-.+..-.+.-....+....-...+.-..+.-...+......-.+..-.+.-..+.-.+.-..+........-..+...-..+.-..+.-.+.-..+..-...+.-.+.-..+.-..+......-.+..-.
```
[Try it online](https://tio.run/nexus/brainfuck#fVSBDYMwDDvIii9AfQTx/xkMIdraSbRJrEBD4thO74ET53GNgQPXAIPg84vnwrvMR@gyt4LyxbvIhtzJf7xB34pZ6as3S4SX2@FrWXX3NlYBJHQaMt9Ab0pw6S9WhsmJsuF1vfEEIEFfoKhprAnWbKlzC8j0whVpZZIUwqSaQWqomoLI0Fh6VDJX42y1dEp6YFZeP6vy@pVogMAJugM2zBB7mtINgS5K8oYztveZbGvUNUwWsT0FaRCKh7cBt1dEWfqwmPEVmw2FiI9EWTOLqcsyc/EvbfjRkdPYo8Ak82AkV1dPu6SbnjK16pTwSNOr@Kg5jqinsJ1eZDtVc68cmulQafy4M973Dw "brainfuck – TIO Nexus")
[Answer]
# Bubblegum, distance 0
The code is 187 bytes long:
```
00000000: 6591 8911 c340 0c02 6b83 fe7b ca63 8915 [[email protected]](/cdn-cgi/l/email-protection)..{.c..
00000010: 33ce 1f90 11b7 b66c 5b92 adfd 998f 91b4 3......l[.......
00000020: 13f6 b8c8 deb7 24cd e7e4 e872 5479 4c4d ......$....rTyLM
00000030: 22e2 44b0 8900 7905 2c92 6ef1 68b1 48a2 ".D...y.,.n.h.H.
00000040: 2081 b554 9b23 df2c cde8 4d3f e43e 261c ..T.#.,..M?.>&.
00000050: 0a0b 3331 1274 32cc 7c29 0a7b 14f6 6d7a ..31.t2.|).{..mz
00000060: f3ba eab5 063c 8ca0 f1ec b284 0baa 51a8 .....<........Q.
00000070: 0cc9 ee7f 40f0 ade8 b821 cb27 bc1a a318 ....@....!.'....
00000080: e637 e50b 17cc 6db8 c070 3b50 c29d 08eb .7....m..p;P....
00000090: b3e3 9d10 e0af cbe0 1b0d 5530 cc81 ba32 ..........U0...2
000000a0: 8b22 829b e186 d559 22e3 ac90 2bfc 60a1 .".....Y"...+.`.
000000b0: 4333 8ec2 8d3d 19c4 7dd5 17 C3...=..}..
```
[Try it online](https://tio.run/nexus/bubblegum#VZJLi5YxDIX3/orjKIoooem9Xgd04cIBhXEhbmzSFkFHRNyMl98@5p3v/WDMIl2UPD0np1dur8fIqTFqY4aG6ODUeWSpAWsWgfYcttsETLI6JfpC9JuU6NaBwMYIQSd4NQdmKZCcFUmaRx9roLW60FgiEOi6vn48nEeGNwaHlSFVK8Y0ho86MMuMmLV4pFgaosYBHCbvbu3H@eWbs50RjOH99IhRnEl2DqW5BK@mI8/FyFUYsXYPnNArG7@kR/SNPtPro464MVxlSEoRTXzAWF6hY1bEERZmDBM@s2ITck53DEFnL@j5vSMjGcN1J7aUwGBfIoJXRVHf7MJ2ytGc5lH6hghMPz39eWA7pYtfOyMbYwXpmF0SXA6Kqt1h8VSIrxFOekfiXvd9PN0XSu@OOsqmQ7VhzrIQ3XKWhtmQ6i1q8RaTckcPvDNOt3ab7t/IpRpj5lAwkxniYjbykAo1OoIkBzM14OoUY5Rt8oLo@5O3NxjNGBJmQBvsMF1f9vq0nyJuIKVgDN023oM/ZrvVe2fN74xujCreo/ommFwzRkptyzugq/07L8u0uc7GOLkGfNiOh/TpqEOMES0T1KkGGmGAm0aUMZJZw3/1cvuoz4j@El1d/QM).
] |
[Question]
[
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Update the question so it focuses on one problem only by [editing this post](/posts/37992/edit).
Closed 9 years ago.
[Improve this question](/posts/37992/edit)
This is my first contest, so please tell me what I can do to improve.
The object of this contest is to write program lines in your language of choice that are both valid code and self-descriptive in English, such as this Golfscript program:
```
This program outputs 4 twice.
```
You may use any language features, libraries, #defines, etc. that you want; however, a setup must not be over 10 lines (no, you can't cheat using ; or any such line separator :P).
The program with the most upvotes by midnight on October 1st wins.
[Answer]
## Python
```
# This "program" does nothing and assumes "valid code" means it doesn't throw an error.
```
You *might* want to tighten up the rules a bit.
[Answer]
# C
This was too easy...
```
#define This int
#define program main(){
#define prints printf(
#define and );
#define exits }
This program prints "Hello world!" and exits
```
## [English](http://esolangs.org/wiki/English)
```
This program outputs 99 verses in the manner:
"N bottles of beer on the wall
N bottles of beer
Take one down and pass it around
N-1 bottles of beer on the wall",
where N is replaced by numbers from 99 to 1
and 1-1=0 is replaced by "No more".
After that there is hundredth verse:
"No more bottles of beer on the wall
No more bottles of beer
Go to the store and buy some more
99 bottles of beer on the wall".
```
[Answer]
# OS X say
```
say whatever you want man!
```
] |
[Question]
[
Find the combination of N number of letters that make up the most words of length N.
For example:
```
n r u -> run, urn
dstu -> dust, stud
(these are just examples, not the best combination of 3,4 length sets of letters)
```
The challenge in the case is to start with length N=3 and end at N=11. Which combination of letters gives you the most words and what are those words?
For the contest, please use this [word list](http://web.mit.edu/kilroi/Public/bot/wordlist). It contains 71,193 words. Please also let us know the time (in seconds) and CPU type/speed that you are using.
[Answer]
### Ruby, 116 97 92 characters
```
9.times{|n|p IO.read('w').split.group_by{|s|s.chars.sort}.max_by{|k,v|k.size!=n+3?0:v.size}}
```
The wordlist is expected in the file `w` in the local directory. Program runs less than a second.
*Output:*
```
[["A", "E", "T"], ["ATE", "EAT", "ETA", "TAE", "TEA"]]
[["A", "E", "L", "S"], ["ALES", "ELSA", "LEAS", "LESA", "SALE", "SEAL"]]
[["A", "E", "L", "S", "T"], ["LEAST", "SLATE", "STAEL", "STALE", "STEAL", "TALES", "TEALS", "TESLA"]]
[["A", "C", "E", "R", "S", "T"], ["CARETS", "CASTER", "CATERS", "CRATES", "REACTS", "RECAST", "TRACES"]]
[["A", "D", "E", "E", "G", "N", "R"], ["ANGERED", "DERANGE", "ENRAGED", "GRANDEE", "GRENADE"]]
[["A", "E", "G", "I", "L", "N", "R", "T"], ["ALERTING", "ALTERING", "INTEGRAL", "RELATING", "TRIANGLE"]]
[["A", "A", "C", "E", "I", "N", "R", "S", "T"], ["ASCERTAIN", "CARTESIAN", "SECTARIAN"]]
[["A", "D", "I", "I", "M", "N", "N", "O", "O", "T"], ["ADMONITION", "DOMINATION"]]
[["A", "C", "G", "H", "I", "I", "L", "M", "O", "R", "T"], ["ALGORITHMIC", "LOGARITHMIC"]]
```
[Answer]
# k (39)
Expects the wordlist to be in a file called `w` in the current directory.
```
{i?max i:#:'=:{x@<x}'(w@=:#:'w:0:`:w)x}
```
Example usage (calculating result for every permissible input, runs in 640 ms on single core of Pentium E2160)
```
k){i?max i:#:'=:{x@<x}'(w@=:#:'w:0:`:w)x}'3+!9
("AET";"AELS";"AELST";"ACERST";"ADEEGNR";"AEGILNRT";"AACEINRST";"ADIIMNNOOT";..
```
[Answer]
# Haskell, 341 chars
Takes the word list on standard input, and return **all possible solutions** for each `2 < n < 12` a quadruple of the form:
```
(n, s, l, w)
```
where
```
n = Selected number of letter (between 3 and 11)
s = Size of the biggest sets of words of given size
l = The ordered sets of letters that compose words
w = The sets of words for each set of letters
```
for example: `(3,5,["AET"],[["ATE","EAT","ETA","TAE","TEA"]])`
## Compressed code
```
import Data.List;import Data.Function;main=do interact$unlines.map(show.(\x->(length.head.head$x,length.head$x,map(sort.head)$x,x)).last.groupBy((==)`on`length).sortBy(compare`on`length)).groupBy((==)`on`(length.head)).sortBy(compare`on`(length.head)).groupBy((==)`on`sort).sortBy(compare`on`sort).filter(\x->length x>=3&&length x<=11).lines
```
## A bit more readable code
```
import Data.List
import Data.Function
main = do
interact $ unlines . map ( show . (\x -> (length . head . head $ x, length . head $ x, map (sort . head) $ x, x)) . last . groupBy ((==) `on`length) . sortBy (compare `on` length)) . groupBy ((==) `on` (length . head)) . sortBy (compare `on ` (length . head)) . groupBy ((==) `on` sort) . sortBy (compare `on` sort) . filter (\x -> length x >= 3 && length x <= 11) . lines
```
## Execution
Compiling with: `ghc -O2 letter.hs`
Running with: `time ./letter < wordlist`
Result: `1.75s user 0.03s system 99% cpu 1.784 total`
CPU info: `Intel i7 8x3.4 GHz 64 bits`
## Output
```
(3,5,["AET"],[["ATE","EAT","ETA","TAE","TEA"]])
(4,6,["AELS","AEST","OPST"],[["ALES","ELSA","LEAS","LESA","SALE","SEAL"],["ATES","EAST","EATS","SATE","SEAT","TEAS"],["OPTS","POST","POTS","SPOT","STOP","TOPS"]])
(5,8,["AELST"],[["LEAST","SLATE","STAEL","STALE","STEAL","TALES","TEALS","TESLA"]])
(6,7,["ACERST"],[["CARETS","CASTER","CATERS","CRATES","REACTS","RECAST","TRACES"]])
(7,5,["ACDEILM","ADEEGNR","ADEHRST","ADEIRST","AEIRSTT","AELPRSY","EIPRSST"],[["CLAIMED","DECIMAL","DECLAIM","MALICED","MEDICAL"],["ANGERED","DERANGE","ENRAGED","GRANDEE","GRENADE"],["DEARTHS","HARDEST","HATREDS","THREADS","TRASHED"],["ARIDEST","ASTRIDE","STAIDER","TARDIES","TIRADES"],["ARTIEST","ARTISTE","ATTIRES","IRATEST","TASTIER"],["PARLEYS","PARSLEY","PLAYERS","REPLAYS","SPARELY"],["PERSIST","PRIESTS","SPRIEST","SPRITES","STRIPES"]])
(8,5,["AEGILNRT","AEGINRST"],[["ALERTING","ALTERING","INTEGRAL","RELATING","TRIANGLE"],["ANGRIEST","GANTRIES","INGRATES","RANGIEST","TANGIERS"]])
(9,3,["AACEINRST","ABEEILRST","ACDEINOTU","ACEGINRRT","ACEINSSTT","ADEGGINNR","ADEGINRRW","AEEGNRSST","AEGHILNRT","AEGIMNRST","AEILMSTTU","CEINORSTU","DEEINRSST","EGIILNNST","EGIINPRRS","EGINORRST"],[["ASCERTAIN","CARTESIAN","SECTARIAN"],["BEASTLIER","BLEARIEST","LIBERATES"],["AUCTIONED","CAUTIONED","EDUCATION"],["CRATERING","RETRACING","TERRACING"],["CATTINESS","SCANTIEST","TACITNESS"],["DANGERING","DERANGING","GARDENING"],["REDRAWING","REWARDING","WARDERING"],["ESTRANGES","GREATNESS","SERGEANTS"],["EARTHLING","HALTERING","LATHERING"],["EMIGRANTS","MASTERING","STREAMING"],["MUTILATES","STIMULATE","ULTIMATES"],["COUNTRIES","CRETINOUS","NEUROTICS"],["DISSENTER","RESIDENTS","TIREDNESS"],["ENLISTING","LISTENING","TINSELING"],["REPRISING","RESPIRING","SPRINGIER"],["RESORTING","RESTORING","ROSTERING"]])
(10,2,["AAAILNRSTU","AABEIILNST","AACDEGLOTU","AACEGLOSTU","AACEINRSST","AAEILNORST","AAEINOPRRT","AAGILLMNRY","AAGINNOSTT","ABDDEIORSS","ACCEHIMSST","ACDEEILNRT","ACDEGIIMNT","ACDEIIMNOT","ACDEIIPRST","ACDEINOORT","ACEEILMSST","ACEEINNRST","ACEEINRSST","ACEGHINRTT","ACEIINOTTX","ACEILNOSST","ACGIINNOTU","ACGILLNOPS","ADEEGINNRS","ADEEHILPRS","ADEEIMNNOT","ADEEINRSTT","ADEEINRSTU","ADEFORRSTW","ADEGIILMNS","ADEILPSTTU","ADEINNOOTT","ADIIMNNOOT","AEEGIMNPRT","AEEGINNRST","AEEGINNRTV","AEEHILRSTT","AEEHINRSST","AEEHORSSUW","AEEINNORTV","AEEIPRSSTT","AEEMNSSTTT","AEGHILNRST","AEGHINRSTT","AEGIINNPRT","AEGINRRSTT","AEHIRSSTTW","AEIILORSST","AFIILNORTT","AGHILMORST","AGIILMNTTU","AIILNOOPST","BDEGILNORU","BEGILNORST","CCEEGHIKNR","CCEEGINORT","CCEGINNORT","CDDEINOSTU","CDEEIINRST","CDEEIORRSV","CDEEMOPRSS","CDEEOPRRSU","CDEGIINNRS","CDEIINORST","CDEIINRSTT","CDEINORSTU","CEFGIINRTY","CEFGINORSU","CEGHIIKNNT","CEGINNNOTT","CEGINNORSV","CEGINNORTU","CEIINNOPST","CEINOPRSSU","DEEEINNRTV","DEEEIPRSTX","DEEELOPRSV","DEEFIILNRS","DEEFORRSST","DEEIMNORSZ","DEGILNOSTU","DEGINNRSSU","DEIINOOPST","EEGINNPRST","EEGLNORSTT","EEIIMPRSSV","EEIINOPRTT","EEINPRSSTT","EELOPRSSTY","EFIMNORSTU","EGIINPRSST","EGILMNOOSS","EIIMNOPRSS","EIMNNRSTTU","EIMNOPRSTU","GHILOPSSTT"],[["AUSTRALIAN","SATURNALIA"],["BANALITIES","INSATIABLE"],["CATALOGUED","COAGULATED"],["CATALOGUES","COAGULATES"],["ASCERTAINS","SECTARIANS"],["RATIONALES","SENATORIAL"],["PRAETORIAN","REPARATION"],["ALARMINGLY","MARGINALLY"],["ANTAGONIST","STAGNATION"],["BROADSIDES","SIDEBOARDS"],["CATECHISMS","SCHEMATICS"],["CREDENTIAL","INTERLACED"],["DECIMATING","MEDICATING"],["DECIMATION","MEDICATION"],["PATRICIDES","PEDIATRICS"],["COORDINATE","DECORATION"],["CLEMATISES","TIMESCALES"],["NECTARINES","TRANSIENCE"],["ANCESTRIES","RESISTANCE"],["CHATTERING","RATCHETING"],["EXCITATION","INTOXICATE"],["COASTLINES","SECTIONALS"],["AUCTIONING","CAUTIONING"],["COLLAPSING","SCALLOPING"],["GRENADINES","SERENADING"],["DEALERSHIP","LEADERSHIP"],["DENOMINATE","EMENDATION"],["REINSTATED","STRAITENED"],["UNREADIEST","UNSTEADIER"],["AFTERWORDS","FORWARDEST"],["MISDEALING","MISLEADING"],["PLATITUDES","STIPULATED"],["DENOTATION","DETONATION"],["ADMONITION","DOMINATION"],["IMPREGNATE","PERMEATING"],["ARGENTINES","TANGERINES"],["ENERVATING","VENERATING"],["EARTHLIEST","STEALTHIER"],["EARTHINESS","HEARTINESS"],["HOUSEWARES","WAREHOUSES"],["ENERVATION","VENERATION"],["STRIPTEASE","TAPESTRIES"],["STATEMENTS","TESTAMENTS"],["EARTHLINGS","SLATHERING"],["SHATTERING","STRAIGHTEN"],["PERTAINING","REPAINTING"],["REGISTRANT","RESTARTING"],["SWARTHIEST","SWEATSHIRT"],["SOLITAIRES","SOLITARIES"],["FILTRATION","FLIRTATION"],["ALGORITHMS","LOGARITHMS"],["MUTILATING","ULTIMATING"],["POSITIONAL","SPOLIATION"],["BOULDERING","REDOUBLING"],["BOLSTERING","LOBSTERING"],["CHECKERING","RECHECKING"],["EGOCENTRIC","GEOCENTRIC"],["CONCERTING","CONCRETING"],["DEDUCTIONS","DISCOUNTED"],["INDISCREET","IRIDESCENT"],["DISCOVERER","REDISCOVER"],["COMPRESSED","DECOMPRESS"],["PROCEDURES","REPRODUCES"],["DISCERNING","RESCINDING"],["DIRECTIONS","DISCRETION"],["DISTINCTER","INTERDICTS"],["INTRODUCES","REDUCTIONS"],["CERTIFYING","RECTIFYING"],["CONFIGURES","REFOCUSING"],["KITCHENING","THICKENING"],["CONTENTING","CONTINGENT"],["CONSERVING","CONVERSING"],["COUNTERING","RECOUNTING"],["INCEPTIONS","INSPECTION"],["PERCUSSION","SUPERSONIC"],["INTERVENED","REINVENTED"],["EXPEDITERS","PREEXISTED"],["DEVELOPERS","REDEVELOPS"],["FRIENDLIES","INFIELDERS"],["DEFROSTERS","FORTRESSED"],["MODERNIZES","SERMONIZED"],["LONGITUDES","UNGODLIEST"],["UNDERSIGNS","UNDRESSING"],["DEPOSITION","POSITIONED"],["PRESENTING","SERPENTING"],["LONGSTREET","LORGNETTES"],["IMPRESSIVE","PERMISSIVE"],["PETITIONER","REPETITION"],["PERSISTENT","PRETTINESS"],["POLYESTERS","PROSELYTES"],["MISFORTUNE","UNIFORMEST"],["PERSISTING","SPRINGIEST"],["GLOOMINESS","NEOLOGISMS"],["IMPRESSION","PERMISSION"],["INSTRUMENT","NUTRIMENTS"],["IMPORTUNES","RESUMPTION"],["SPOTLIGHTS","STOPLIGHTS"]])
(11,2,["AABCDEORRST","AACGGILNOTU","AACGHILLPRY","AAEIILNORTZ","AAEILMNPRST","ABCEEEILRSV","ABCEEFIILRT","ACDEEINORST","ACDEFIIINOT","ACDEINOORST","ACEEIIPPRTT","ACEINOOPRRT","ACGHIILMORT","ACIILLNOOST","ADEEILMNRST","ADEEIMNNOST","ADEIINOPRTT","ADEINNOOSTT","AEEIIMPRSTV","AEEILNTTTVY","AEEIMNNORTU","AEGHILNOOST","AEGIINNORTT","AEGIINNRSTT","AEIMNOPRTTU","CDEEEOPRRSS","CDEEIORRSSV","CDEIINNOORT","CDEIINOPRST","DEEFIIINNST","EEEINPRRSST","EEEIOPRRRST","EEGIINNNRTV","EEHLOPRRSTU","EEIINOPRSTT","EIIMNOPRSSS"],[["BROADCASTER","REBROADCAST"],["CATALOGUING","COAGULATING"],["CALLIGRAPHY","GRAPHICALLY"],["RATIONALIZE","REALIZATION"],["PARLIAMENTS","PATERNALISM"],["RECEIVABLES","SERVICEABLE"],["CERTIFIABLE","RECTIFIABLE"],["CONSIDERATE","DESECRATION"],["DEIFICATION","EDIFICATION"],["COORDINATES","DECORATIONS"],["PERIPATETIC","PRECIPITATE"],["INCORPORATE","PROCREATION"],["ALGORITHMIC","LOGARITHMIC"],["COLONIALIST","OSCILLATION"],["DERAILMENTS","STREAMLINED"],["DENOMINATES","EMENDATIONS"],["PARTITIONED","TREPIDATION"],["DENOTATIONS","DETONATIONS"],["IMPERATIVES","SEMIPRIVATE"],["ATTENTIVELY","TENTATIVELY"],["ENUMERATION","MOUNTAINEER"],["ANTHOLOGIES","THEOLOGIANS"],["INTEGRATION","ORIENTATING"],["REINSTATING","STRAITENING"],["IMPORTUNATE","PERMUTATION"],["PREDECESSOR","REPROCESSED"],["DISCOVERERS","REDISCOVERS"],["CONDITIONER","RECONDITION"],["DESCRIPTION","PREDICTIONS"],["INDEFINITES","INTENSIFIED"],["ENTERPRISES","INTERSPERSE"],["REPERTOIRES","REPERTORIES"],["INTERVENING","REINVENTING"],["REUPHOLSTER","UPHOLSTERER"],["PETITIONERS","REPETITIONS"],["IMPRESSIONS","PERMISSIONS"]])
```
[Answer]
# Mathematica 192
A bit wordy, but it returns multiple correct answers for the same word length (when they exist):
```
w = Flatten[Characters@Import["words.txt", "Data"], 1];
Table[Cases[#, {x_, Max[#[[All, -1]]]} :> {Characters@x[[1]], x}] &[{StringJoin /@ #,
Length[#]} & /@ GatherBy[Select[w, Length[#] == k &], Sort[#1] &]], {k, 3, 11}]
```
Timing: `1.228453 s`; 2.8 GHz Intel i7 Mac OS X 10.8.3
Results for lengths 3-9 are displayed below. There are too many winning combinations for sets of 10, 11 letters to be displayed here.
>
> 
>
>
>
[Answer]
## GolfScript (53 chars)
```
n/{[.$\]}%$'']({.1<2$<{1>+}*}/]9,{3+\{(,2$=*,}$)p}/];
```
or
```
n/{[.$\]}%$'']({.1<2$<{1>+}*}/]3{\{(,2$=*,}$)p\)}9*;;
```
I assume that there is at least one word of each length in the range processed: otherwise things will go badly wrong.
```
["AET" "ATE" "EAT" "ETA" "TAE" "TEA"]
["AELS" "ALES" "ELSA" "LEAS" "LESA" "SALE" "SEAL"]
["AELST" "LEAST" "SLATE" "STAEL" "STALE" "STEAL" "TALES" "TEALS" "TESLA"]
["ACERST" "CARETS" "CASTER" "CATERS" "CRATES" "REACTS" "RECAST" "TRACES"]
["ADEEGNR" "ANGERED" "DERANGE" "ENRAGED" "GRANDEE" "GRENADE"]
["AEGINRST" "ANGRIEST" "GANTRIES" "INGRATES" "RANGIEST" "TANGIERS"]
["AACEINRST" "ASCERTAIN" "CARTESIAN" "SECTARIAN"]
["EEINPRSSTT" "PERSISTENT" "PRETTINESS"]
["EEIINOPRSTT" "PETITIONERS" "REPETITIONS"]
```
Took about 2 minutes on my 2GHz 64-bit CPU.
[Answer]
## J (96)
```
(echo@(((~.#~([=>./)@(#/.~))="0/[)@:((/:{[)&.>)#[)@((LF cut 1!:1[3)&([#~]=>@(#&.>)@[)))&.>3+i.9
```
It runs in a few seconds on my 2Ghz Pentium 4. It expects the wordlist on `stdin`, i.e. `cat wordlist | jconsole combinations.ijs`
Output:
```
┌───┬───┬───┬───┬───┐
│ATE│EAT│ETA│TAE│TEA│
└───┴───┴───┴───┴───┘
┌────┬────┬────┬────┬────┬────┐
│ALES│ELSA│LEAS│LESA│SALE│SEAL│
├────┼────┼────┼────┼────┼────┤
│ATES│EAST│EATS│SATE│SEAT│TEAS│
├────┼────┼────┼────┼────┼────┤
│OPTS│POST│POTS│SPOT│STOP│TOPS│
└────┴────┴────┴────┴────┴────┘
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│LEAST│SLATE│STAEL│STALE│STEAL│TALES│TEALS│TESLA│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
┌──────┬──────┬──────┬──────┬──────┬──────┬──────┐
│CARETS│CASTER│CATERS│CRATES│REACTS│RECAST│TRACES│
└──────┴──────┴──────┴──────┴──────┴──────┴──────┘
┌───────┬───────┬───────┬───────┬───────┐
│ANGERED│DERANGE│ENRAGED│GRANDEE│GRENADE│
├───────┼───────┼───────┼───────┼───────┤
│ARIDEST│ASTRIDE│STAIDER│TARDIES│TIRADES│
├───────┼───────┼───────┼───────┼───────┤
│ARTIEST│ARTISTE│ATTIRES│IRATEST│TASTIER│
├───────┼───────┼───────┼───────┼───────┤
│CLAIMED│DECIMAL│DECLAIM│MALICED│MEDICAL│
├───────┼───────┼───────┼───────┼───────┤
│DEARTHS│HARDEST│HATREDS│THREADS│TRASHED│
├───────┼───────┼───────┼───────┼───────┤
│PARLEYS│PARSLEY│PLAYERS│REPLAYS│SPARELY│
├───────┼───────┼───────┼───────┼───────┤
│PERSIST│PRIESTS│SPRIEST│SPRITES│STRIPES│
└───────┴───────┴───────┴───────┴───────┘
┌────────┬────────┬────────┬────────┬────────┐
│ALERTING│ALTERING│INTEGRAL│RELATING│TRIANGLE│
├────────┼────────┼────────┼────────┼────────┤
│ANGRIEST│GANTRIES│INGRATES│RANGIEST│TANGIERS│
└────────┴────────┴────────┴────────┴────────┘
┌─────────┬─────────┬─────────┐
│ASCERTAIN│CARTESIAN│SECTARIAN│
├─────────┼─────────┼─────────┤
│AUCTIONED│CAUTIONED│EDUCATION│
├─────────┼─────────┼─────────┤
│BEASTLIER│BLEARIEST│LIBERATES│
├─────────┼─────────┼─────────┤
│CATTINESS│SCANTIEST│TACITNESS│
├─────────┼─────────┼─────────┤
│COUNTRIES│CRETINOUS│NEUROTICS│
├─────────┼─────────┼─────────┤
│CRATERING│RETRACING│TERRACING│
├─────────┼─────────┼─────────┤
│DANGERING│DERANGING│GARDENING│
├─────────┼─────────┼─────────┤
│DISSENTER│RESIDENTS│TIREDNESS│
├─────────┼─────────┼─────────┤
│EARTHLING│HALTERING│LATHERING│
├─────────┼─────────┼─────────┤
│EMIGRANTS│MASTERING│STREAMING│
├─────────┼─────────┼─────────┤
│ENLISTING│LISTENING│TINSELING│
├─────────┼─────────┼─────────┤
│ESTRANGES│GREATNESS│SERGEANTS│
├─────────┼─────────┼─────────┤
│MUTILATES│STIMULATE│ULTIMATES│
├─────────┼─────────┼─────────┤
│REDRAWING│REWARDING│WARDERING│
├─────────┼─────────┼─────────┤
│REPRISING│RESPIRING│SPRINGIER│
├─────────┼─────────┼─────────┤
│RESORTING│RESTORING│ROSTERING│
└─────────┴─────────┴─────────┘
┌──────────┬──────────┐
│ADMONITION│DOMINATION│
├──────────┼──────────┤
│AFTERWORDS│FORWARDEST│
├──────────┼──────────┤
│ALARMINGLY│MARGINALLY│
├──────────┼──────────┤
│ALGORITHMS│LOGARITHMS│
├──────────┼──────────┤
│ANCESTRIES│RESISTANCE│
├──────────┼──────────┤
│ANTAGONIST│STAGNATION│
├──────────┼──────────┤
│ARGENTINES│TANGERINES│
├──────────┼──────────┤
│ASCERTAINS│SECTARIANS│
├──────────┼──────────┤
│AUCTIONING│CAUTIONING│
├──────────┼──────────┤
│AUSTRALIAN│SATURNALIA│
├──────────┼──────────┤
│BANALITIES│INSATIABLE│
├──────────┼──────────┤
│BOLSTERING│LOBSTERING│
├──────────┼──────────┤
│BOULDERING│REDOUBLING│
├──────────┼──────────┤
│BROADSIDES│SIDEBOARDS│
├──────────┼──────────┤
│CATALOGUED│COAGULATED│
├──────────┼──────────┤
│CATALOGUES│COAGULATES│
├──────────┼──────────┤
│CATECHISMS│SCHEMATICS│
├──────────┼──────────┤
│CERTIFYING│RECTIFYING│
├──────────┼──────────┤
│CHATTERING│RATCHETING│
├──────────┼──────────┤
│CHECKERING│RECHECKING│
├──────────┼──────────┤
│CLEMATISES│TIMESCALES│
├──────────┼──────────┤
│COASTLINES│SECTIONALS│
├──────────┼──────────┤
│COLLAPSING│SCALLOPING│
├──────────┼──────────┤
│COMPRESSED│DECOMPRESS│
├──────────┼──────────┤
│CONCERTING│CONCRETING│
├──────────┼──────────┤
│CONFIGURES│REFOCUSING│
├──────────┼──────────┤
│CONSERVING│CONVERSING│
├──────────┼──────────┤
│CONTENTING│CONTINGENT│
├──────────┼──────────┤
│COORDINATE│DECORATION│
├──────────┼──────────┤
│COUNTERING│RECOUNTING│
├──────────┼──────────┤
│CREDENTIAL│INTERLACED│
├──────────┼──────────┤
│DEALERSHIP│LEADERSHIP│
├──────────┼──────────┤
│DECIMATING│MEDICATING│
├──────────┼──────────┤
│DECIMATION│MEDICATION│
├──────────┼──────────┤
│DEDUCTIONS│DISCOUNTED│
├──────────┼──────────┤
│DEFROSTERS│FORTRESSED│
├──────────┼──────────┤
│DENOMINATE│EMENDATION│
├──────────┼──────────┤
│DENOTATION│DETONATION│
├──────────┼──────────┤
│DEPOSITION│POSITIONED│
├──────────┼──────────┤
│DEVELOPERS│REDEVELOPS│
├──────────┼──────────┤
│DIRECTIONS│DISCRETION│
├──────────┼──────────┤
│DISCERNING│RESCINDING│
├──────────┼──────────┤
│DISCOVERER│REDISCOVER│
├──────────┼──────────┤
│DISTINCTER│INTERDICTS│
├──────────┼──────────┤
│EARTHINESS│HEARTINESS│
├──────────┼──────────┤
│EARTHLIEST│STEALTHIER│
├──────────┼──────────┤
│EARTHLINGS│SLATHERING│
├──────────┼──────────┤
│EGOCENTRIC│GEOCENTRIC│
├──────────┼──────────┤
│ENERVATING│VENERATING│
├──────────┼──────────┤
│ENERVATION│VENERATION│
├──────────┼──────────┤
│EXCITATION│INTOXICATE│
├──────────┼──────────┤
│EXPEDITERS│PREEXISTED│
├──────────┼──────────┤
│FILTRATION│FLIRTATION│
├──────────┼──────────┤
│FRIENDLIES│INFIELDERS│
├──────────┼──────────┤
│GLOOMINESS│NEOLOGISMS│
├──────────┼──────────┤
│GRENADINES│SERENADING│
├──────────┼──────────┤
│HOUSEWARES│WAREHOUSES│
├──────────┼──────────┤
│IMPORTUNES│RESUMPTION│
├──────────┼──────────┤
│IMPREGNATE│PERMEATING│
├──────────┼──────────┤
│IMPRESSION│PERMISSION│
├──────────┼──────────┤
│IMPRESSIVE│PERMISSIVE│
├──────────┼──────────┤
│INCEPTIONS│INSPECTION│
├──────────┼──────────┤
│INDISCREET│IRIDESCENT│
├──────────┼──────────┤
│INSTRUMENT│NUTRIMENTS│
├──────────┼──────────┤
│INTERVENED│REINVENTED│
├──────────┼──────────┤
│INTRODUCES│REDUCTIONS│
├──────────┼──────────┤
│KITCHENING│THICKENING│
├──────────┼──────────┤
│LONGITUDES│UNGODLIEST│
├──────────┼──────────┤
│LONGSTREET│LORGNETTES│
├──────────┼──────────┤
│MISDEALING│MISLEADING│
├──────────┼──────────┤
│MISFORTUNE│UNIFORMEST│
├──────────┼──────────┤
│MODERNIZES│SERMONIZED│
├──────────┼──────────┤
│MUTILATING│ULTIMATING│
├──────────┼──────────┤
│NECTARINES│TRANSIENCE│
├──────────┼──────────┤
│PATRICIDES│PEDIATRICS│
├──────────┼──────────┤
│PERCUSSION│SUPERSONIC│
├──────────┼──────────┤
│PERSISTENT│PRETTINESS│
├──────────┼──────────┤
│PERSISTING│SPRINGIEST│
├──────────┼──────────┤
│PERTAINING│REPAINTING│
├──────────┼──────────┤
│PETITIONER│REPETITION│
├──────────┼──────────┤
│PLATITUDES│STIPULATED│
├──────────┼──────────┤
│POLYESTERS│PROSELYTES│
├──────────┼──────────┤
│POSITIONAL│SPOLIATION│
├──────────┼──────────┤
│PRAETORIAN│REPARATION│
├──────────┼──────────┤
│PRESENTING│SERPENTING│
├──────────┼──────────┤
│PROCEDURES│REPRODUCES│
├──────────┼──────────┤
│RATIONALES│SENATORIAL│
├──────────┼──────────┤
│REGISTRANT│RESTARTING│
├──────────┼──────────┤
│REINSTATED│STRAITENED│
├──────────┼──────────┤
│SHATTERING│STRAIGHTEN│
├──────────┼──────────┤
│SOLITAIRES│SOLITARIES│
├──────────┼──────────┤
│SPOTLIGHTS│STOPLIGHTS│
├──────────┼──────────┤
│STATEMENTS│TESTAMENTS│
├──────────┼──────────┤
│STRIPTEASE│TAPESTRIES│
├──────────┼──────────┤
│SWARTHIEST│SWEATSHIRT│
├──────────┼──────────┤
│UNDERSIGNS│UNDRESSING│
├──────────┼──────────┤
│UNREADIEST│UNSTEADIER│
└──────────┴──────────┘
┌───────────┬───────────┐
│ALGORITHMIC│LOGARITHMIC│
├───────────┼───────────┤
│ANTHOLOGIES│THEOLOGIANS│
├───────────┼───────────┤
│ATTENTIVELY│TENTATIVELY│
├───────────┼───────────┤
│BROADCASTER│REBROADCAST│
├───────────┼───────────┤
│CALLIGRAPHY│GRAPHICALLY│
├───────────┼───────────┤
│CATALOGUING│COAGULATING│
├───────────┼───────────┤
│CERTIFIABLE│RECTIFIABLE│
├───────────┼───────────┤
│COLONIALIST│OSCILLATION│
├───────────┼───────────┤
│CONDITIONER│RECONDITION│
├───────────┼───────────┤
│CONSIDERATE│DESECRATION│
├───────────┼───────────┤
│COORDINATES│DECORATIONS│
├───────────┼───────────┤
│DEIFICATION│EDIFICATION│
├───────────┼───────────┤
│DENOMINATES│EMENDATIONS│
├───────────┼───────────┤
│DENOTATIONS│DETONATIONS│
├───────────┼───────────┤
│DERAILMENTS│STREAMLINED│
├───────────┼───────────┤
│DESCRIPTION│PREDICTIONS│
├───────────┼───────────┤
│DISCOVERERS│REDISCOVERS│
├───────────┼───────────┤
│ENTERPRISES│INTERSPERSE│
├───────────┼───────────┤
│ENUMERATION│MOUNTAINEER│
├───────────┼───────────┤
│IMPERATIVES│SEMIPRIVATE│
├───────────┼───────────┤
│IMPORTUNATE│PERMUTATION│
├───────────┼───────────┤
│IMPRESSIONS│PERMISSIONS│
├───────────┼───────────┤
│INCORPORATE│PROCREATION│
├───────────┼───────────┤
│INDEFINITES│INTENSIFIED│
├───────────┼───────────┤
│INTEGRATION│ORIENTATING│
├───────────┼───────────┤
│INTERVENING│REINVENTING│
├───────────┼───────────┤
│PARLIAMENTS│PATERNALISM│
├───────────┼───────────┤
│PARTITIONED│TREPIDATION│
├───────────┼───────────┤
│PERIPATETIC│PRECIPITATE│
├───────────┼───────────┤
│PETITIONERS│REPETITIONS│
├───────────┼───────────┤
│PREDECESSOR│REPROCESSED│
├───────────┼───────────┤
│RATIONALIZE│REALIZATION│
├───────────┼───────────┤
│RECEIVABLES│SERVICEABLE│
├───────────┼───────────┤
│REINSTATING│STRAITENING│
├───────────┼───────────┤
│REPERTOIRES│REPERTORIES│
├───────────┼───────────┤
│REUPHOLSTER│UPHOLSTERER│
└───────────┴───────────┘
```
[Answer]
## APL (91)
```
{⎕ML←3⋄{⎕←⍵/S}¨↓⍉K∘.≡Z/⍨T=⌈/T←+⌿K∘.≡Z←∪K←{⍵[⍋⍵]}¨S←W/⍨⍵=↑∘⍴¨W←W⊂⍨~⎕TC∊⍨W←80 ¯1⎕MAP'w'}¨2+⍳9
```
Expects the word list to be in a file called `w` in the current directory. Takes about four minutes to run (but it was running in a virtual machine).
The default workspace size in Dyalog APL is 64kb, this is not enough so you need to increase it (I set it to a megabyte).
Explanation:
* `⎕ML←3`: to make `⊂` work as partition
* `{`...`}¨2+⍳9`: for [3..11]
* `W←W⊂⍨~⎕TC∊⍨W←80 ¯1⎕MAP'w'`: read the `w` file and split on terminal control characters (newlines and tab)
* `S←W/⍨⍵=↑∘⍴¨W`: filter out the words of the current length
* `K←{⍵[⍋⍵]}¨S`: sort the letters of each word
* `T←+⌿K∘.≡Z←∪K`: for each unique bag of letters, see how many times it appears
* `Z/⍨T=⌈/T`: select those groups of letters that occur as many times as the most occuring one
* `↓⍉K∘.≡Z/⍨T`: for each group of letters and each word, select those words that have the same letters
* `{⎕←⍵/S}`: for each set of words, select those words from the non-sorted list and display them.
] |
[Question]
[
Your code has to provide the following functions:
```
read(x)
```
>
> Reads a complex number from the standard input. It has to accept and evaluate something in the form of for example `1.42 + 3i`.
>
>
>
```
print(x)
```
>
> Prints the complex number in the form of, for example `1.23 - 4.32i`
>
>
>
```
add(x,y)
sub(x,y)
mult(x,y)
div(x,y)
```
>
> Adds, subtracts, multiplies and respectively divides the two complex numbers.
>
>
>
It is enough if your functions are accurate to two digits after the decimal point, of course, it can be more if you so wish. The input will never have more than two digits after the decimal point.
Any language without native support for complex numbers may be used. Similarly, libraries or other language features which deal with complex numbers are **not** permitted. The point is, you have to do all the handling of complex numbers by yourself.
## Scoring
This is a code golf. The score is the sum of the lengths of the function bodies. For example, `int add(int a, int b) {return a+b;}` will have a length of 11 because of `return a+b`. Your solution must have a main program which demonstrates the use of the functions (for easier evaluation of your solution), but it will not be part of the scoring.
You can store the complex numbers in any way you wish, but the functions must have exactly the same amount of parameters as in the above description.
**EDIT**: For languages that support it, you can use operator overloading instead of the `add`, `sub`, etc. functions.
**EDIT 2:** To prohibit the cheap `#define all_your_code_here A`, I'll try to clarify the "only function bodies count" better: every character in the code counts, except for the overhead required to declare and define the functions and the libraries required to do basic I/O. By basic I/O I still mean no language features which directly deal with complex numbers. The `main` or equivalent where you call these functions don't count but you are not allowed to do anything besides using those functions for demonstrative purpose.
[Answer]
## APL (33 + 16 + 1 + 1 + 14 + 17 = **82**)
APL does have support for complex numbers if you use it (of the format `5J6`, like Python's `5+6j`), but it is of course not used.
I represent complex numbers as a 2-tuple of regular numbers, (A B) where A is the real part and B is the imaginary part. This means I can use APL's `+` and `-` operators directly, as they can be used on multidimensional types. (i.e. `1+2 3 4` gives `3 4 5` and `1 2+20 10` gives `21 12`).
An APL function is represented as `{body}`. Functions are first-class objects. I have counted the function body without the braces, except for `+` and `-` which I've counted as 1 each.
```
read ← {⎕ML←3⋄(1,1-2×'-'∊⍵)×⍎¨⍵⊂⍨⍵∊'.',⎕D} ⍝ 33 chars
print ← {⍕(⊃⍵)'+'(⊃⌽⍵)'i'} ⍝ 16 chars
add ← + ⍝ 1 char
sub ← - ⍝ 1 char
mul ← {(-/⍺×⍵),+/⍺×⌽⍵} ⍝ 14 chars
div ← {⍺mul 1 ¯1×⍵÷+/⍵*2} ⍝ 17 chars
```
Usage:
(clarification: APL is evaluated right-to-left so this is actually calculating 8+9i ÷ 5+6i.)
```
print (read⍞) div (read⍞)
5 + 6i
8 + 9i
1.540983607 + ¯0.04918032787 i
```
[Answer]
## D (205 chars)
```
import stdio;
struct Complex{
real a,b;
this(real a,real b){
this.a=a;
this.b=b;
}
static Complex read(){
Complex c;
readf("%f%+fi",&c.a,&c.b);
return c;
}
/** does both addition and substraction */
Complex opOpBinary(op)(Complex o)if(op=="+"||op=="-"){
mixin("return Complex(a"~op~"o.a,b"~op~"o.b);");
}
Complex opBinary(op)(Complex o)if(op=="*"){
return Complex(a*o.a-b*o.b,a*o.b+b*o.a);
}
Complex opBinary(op)(Complex o)if(op=="/"){
real z=c**2+d**2
return this*Complex(o.a/z,-o.b/z);
}
void write(){
writef("%f%+fi",a,b);
}
}
```
using operator overloading
I didn't count the constructor
[Answer]
## Python, 131 chars
```
add=lambda (a,b),(c,d):(a+c,b+d)
sub=lambda (a,b),(c,d):(a-c,b-d)
mul=lambda (a,b),(c,d):(a*c-b*d,a*d+b*c)
def div(x,(c,d)):z=c**2+d**2;return mul(x,(c/z,-d/z))
def _print(x):print"%f+%fi"%x
read=lambda:tuple(map(float,raw_input()[:-1].split('+')))
x=read()
y=read()
_print(add(x,y))
_print(sub(x,y))
_print(mul(x,y))
_print(div(x,y))
```
Makes lots of use of lambda unpacking, which I'm not including in my "body" count. (I'm counting everything after the first `:`). Kinda cheating, but I'm not really sure how to count it otherwise.
[Answer]
## C# – 369 (I guess)
```
Func<float,float,float[]>C=(x,y)=>new[]{x,y};
Func<float[]>read=()=>{var m=new Regex(@"(\d*(\.\d*)?) *([+-]) *(\d*(\.\d*)?)i").Match(Console.ReadLine()).Groups;return C(float.Parse(m[1].Value),float.Parse(m[2].Value+m[4].Value));};
Action<float[]>print=x=>{Console.WriteLine("{0} {1} {2}i",x[0],x[1]>=0?"+":"-",Math.Abs(x[1]));};
Func<float[],float[],float[]>add=(x,y)=>C(x[0]+y[0],x[1]+y[1]);
Func<float[],float[],float[]>sub=(x,y)=>C(x[0]-y[0],x[1]-y[1]);
Func<float[],float[],float[]>mul=(x,y)=>C(x[0]*y[0]-x[1]*y[1],x[0]*y[1]+x[1]*y[0]);
Func<float[],float[],float[]>div=(x,y)=>mul(x,C(y[0],-y[1])).Select(_=>_/(y[0]*y[0]+y[1]*y[1])).ToArray();
var a = read();
var b = read();
var c = C(3, -7);
var d = C(2, 5);
var e = div(a,c);
var f = mul(b,d);
var g = add(e,f);
print(g);
```
Not sure about the character counting definition, really…
[Answer]
## Haskell 698
Counted everything before `main`. This question struck me as being too
straight forward, so I did everything in my power to make my answer more
interesting. Also Haskell borks if you redefine `Prelude` functions
(div, print, read), so I renamed those.
```
import Control.Arrow
import Control.Monad
import Control.Applicative
import Data.List.Split
a=uncurry(***)
f!g=a(f,g)
j=join(!)
f%b=a$j f b
add=((+)%)
sub=((-)%)
o=join
g#h=(*)<$>g.fst<*>h.snd
c=o.curry
m=add<$>c((fst#fst)!(snd#fst))<*>c((negate.(snd#snd))!(fst#snd))
mul=curry m
b`d1v`c=b`mul`(j (/uncurry(+)(j(^2)c)).second negate$c)
s :: (Show a) => (a, a) -> String
s=uncurry(++).first(++" ").second((++"i").(let g('-':x)="- "++x;g x="+ "++x in g)).j show
pr1nt :: (Show a) => (a, a) -> IO ()
pr1nt=putStrLn.s
t=filter(`notElem`" i")
re4d :: (Read a, Num a) => String -> (a, a)
re4d s|elem '+'s=(\[x,y]->j(read.t)(x,y)).splitOn"+"$s
|0<1=(\[x,y]->read!(negate.read.t)$(x,y)).splitOn"-"$s
main= do
let p = pr1nt
a <- fmap re4d getLine
b <- fmap re4d getLine
p $ a `add` b
p $ a `sub` b
p $ a `mul` b
p $ a `d1v` b
```
This spits a "non-exhaustive pattern-match in input" if the input given
does not match "a (+|-) bi".
[Answer]
## Pascal, 317 bytes
The simple data type `complex` belongs to Extended Pascal’s vocabulary (ISO standard 10206).
However, Standard Pascal – as laid out by ISO standard 7185 – does not support `complex` numbers.
Complying with the task specification, the following implementation is restricted to SP.
Note, the routine `read` had to be renamed to `readComplex`, otherwise Pascal’s *built‑in* `read` procedure will become unavailable.
Similarly, the word `div` is a *reserved word* (identifies the integer division operator) and had to be renamed, too (for the purposes of scoring a three-letter identifier has been chosen).
```
program basicOperationsOnComplexNumbers(input, output);
type
complex = record
r: real;
j: real;
end;
{ In _Standard_ Pascal a `function` can
only return _simple_ data type values. }
complexReference = ↑complex;
var
{ These are used for the test in the main block.
Standard Pascal has a strict block order
(`label` → `const` → `type` → `var` → routines → `begin … end`)
therefore these are “global” variables. }
x, y: complex;
{ Reads a `complex` in Cartesian (rectangular) format. }
procedure readComplex(var x: complex);
begin
{ The `Ln` is necessary so the rest of the line
(in particular the `'i'`) is consumed, too. }
readLn(x.r,x.j)
end;
{ Prints a `complex` in Cartesian (rectangular) format. }
procedure print(x: complex);
begin
{ For non-negative `real` values a space (`' '`) is printed.
Therefore we will need to print the plus sign ourselves. }
write(x.r);if x.j≥0 then write('+');write(x.j,'i')
end;
{ Returns the sum of two `complex` numbers. }
function add(x, y: complex): complexReference;
var
{ The implicitly defined result variable
bearing the function’s name (here `'add'`)
accepts only _complete_ assignments
(this ensures there are no _partially_ defined results).
Therefore we will need a temporary result variable. }
z: complexReference;
begin
x.r≔x.r+y.r;x.j≔x.j+y.j;new(z);z↑≔x;add≔z
end;
{ Returns the difference of two `complex` numbers. }
function sub(x, y: complex): complexReference;
var
z: complexReference;
begin
x.r≔x.r−y.r;x.j≔x.j−y.j;new(z);z↑≔x;sub≔z
end;
{ Returns the product of two `complex` numbers. }
function mult(x, y: complex): complexReference;
var
z: complexReference;
begin
new(z);z↑.r≔x.r*y.r−x.j*y.j;z↑.j≔x.r*y.j+x.j*y.r;mult≔z
end;
{ Returns the quotient of two `complex` numbers.
CAUTION: DOES NOT CHECK FOR NON-ZERO DIVISOR. }
function quo(x, y: complex): complexReference;
var
z: complexReference;
begin
new(z);with z↑do begin
r≔y.r*y.r+y.j*y.j;j≔r;r≔(x.r*y.r+x.j*y.j)/r;j≔(x.j*y.r−x.r*y.j)/j
end;quo≔z
end;
{ === MAIN ========================================================= }
begin
readComplex(x);
readComplex(y);
write(' sum: '); print( add(x, y)↑); writeLn;
write('difference: '); print( sub(x, y)↑); writeLn;
write(' product: '); print(mult(x, y)↑); writeLn;
write(' quotient: '); print( quo(x, y)↑); writeLn
end.
```
Example input:
```
-3.00 + 2.00i
-2.72 + 0.00i
```
Example output (subject to implementation-defined behavior):
```
sum: -5.7200000000000006e+00+ 2.0000000000000000e+00i
difference: -2.7999999999999980e-01+ 2.0000000000000000e+00i
product: 8.1600000000000001e+00-5.4400000000000004e+00i
quotient: 1.1029411764705881e+00-7.3529411764705876e-01i
```
[RosettaCode](https://rosettacode.org/wiki/Arithmetic/Complex#Pascal) │
[FreePascal Compiler Wiki](https://wiki.FreePascal.org/complex_number) │
[GNU Pascal Compiler Programmer’s Guide](https://www.GNU-Pascal.de/gpc/Complex-Number-Operations.html)
] |
[Question]
[
[Project Euler Problem 387](http://projecteuler.net/problem=387) states:
>
> A *Harshad* or *Niven number* is a number that is divisible by the sum of its digits.
> 201 is a Harshad number because it is divisible by 3 (the sum of its digits.)
> When we truncate the last digit from 201, we get 20, which is a Harshad number.
> When we truncate the last digit from 20, we get 2, which is also a Harshad number.
> Let's call a Harshad number that, while recursively truncating the last digit, always results in a Harshad number a *right truncatable Harshad number*.
>
>
> Also:
> 201/3=67 which is prime.
> Let's call a Harshad number that, when divided by the sum of its digits, results in a prime a *strong Harshad number*.
>
>
> Now take the number 2011 which is prime.
> When we truncate the last digit from it we get 201, a strong Harshad number that is also right truncatable.
> Let's call such primes *strong, right truncatable Harshad primes*.
>
>
>
Given a number `n`, determine the first `n` strong, right truncatable Harshad primes.
**Input:** An integer, `n`, where `n<50`. (This means your program will need to be somewhat efficient.)
**Output:** The first `n` strong, right truncatable Harshad primes, with some form of whitespace in between each value.
**Reference Table:**
The first 20 strong, right truncatable Harshad primes are:
1-10:`181 211 271 277 421 457 631 2011 2017 2099`
11-20:`2473 2477 4021 4027 4073 4079 4231 4813 4817 6037 8011`
Shortest code wins. Good luck!
[Answer]
## Python 188 bytes
```
r=range(10)
h=zip(r,r)
w=input()
p=lambda n:all(n%~i for i in range(1,int(n**.5)))%n
while w:
n,s=h.pop(1)
for i in r:
d=s+i;i+=10*n
if i%d<1:h+=[(i,d)]
if p(n/s)and p(i):print i;w-=1
```
This could be made shorter, but my primary concern was efficiency. This code maintains a list of the 'right truncable harshad numbers', as well as the their digital sum, and then uses this list to extend itself by one digit iteratively, allowing only new truncable numbers. I don't see any way to obtain the efficiency required without maintaining such a list. Runtime for `n<=50` is less than one second.
A less efficient version, which calculates everthing as it goes (**139 bytes**, has an acceptable runtime for `n<=31`):
```
s=9
w=input()
while w:
n=s=s+2;x=2;f=0
while n>9:n/=10;z=sum(map(int,`n`));x-=n%z;f=f or(n/z<3)+n/z
if(1<<s)%s==(1<<f)%f==x:print s;w-=1
```
[Answer]
## Python, 204
```
def p(x):
i=2
while x%i:i+=1
return i==x
def h(x):s=sum(map(int,`x`));return[0,x/s][x%s<1]
f=lambda x:x<10or h(x/10)and f(x/10)
n=input()
i=99
while n:
i+=2
if f(i)and p(h(i/10))and p(i):print i;n-=1
```
[Answer]
# K, 190
```
w:{i:0;l:();while[x>#l;if[{$[x>9;$[{&/(h:{a=_a:(d:{x%+/"I"$'$x})x})'{-1_"I"$_[-1]\[$x]}x}q:"I"$-1_$x;$[{(h x)&(p:{(x>1)&&/{x-y*x div y}[_x;2_!_x]})d x}q;$[p x;1;0];0];0];0]}i;l,:i];i+:1];l}
```
.
```
k)w 10
181 211 271 277 421 457 631 2011 2017 2099
```
An easier to read version of the unintelligible one-liner above:
```
d:{x%+/"I"$'$x} /divide number by sum of digits
h:{a=_a:d x} /test for harshad number
t:{-1_"I"$_[-1]\[$x]} /right-truncate a number recursively
r:{&/h't x} /right-truncatable harshad
p:{(x>1)&&/{x-y*x div y}[_x;2_!_x]} /isPrime
s:{(h x)&p d x} /strong harshad
m:{$[x>9;$[r q:"I"$-1_$x;$[s q;$[p x;1;0];0];0];0]} /strong right truncatable harshad prime
w:{i:0;l:();while[x>#l;if[m i;l,:i];i+:1];l} /print the first n harshad srthps
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 22 bytes
```
DṖSḍḌƊÐƤP$×Ḍ÷SƊẒ$Ɗ×Ẓµ#
```
[Try it online!](https://tio.run/##y0rNyan8/9/l4c5pwQ939D7c0XOs6/CEY0sCVA5PB3IObw8@1vVw1yQVoOh0IH1oq/L//6YGAA "Jelly – Try It Online")
This really should be shorter :/
## How it works
```
DṖSḍḌƊÐƤP$×Ḍ÷SƊẒ$Ɗ×Ẓµ# - Main link. No arguments
$× Ɗ× µ# - Read an integer, n, and return the first n integers for which the following three conditions are true:
Ẓ - 1. The integer is prime
DṖSḍḌƊÐƤP - 2. The integer is a right truncatable Harshad number:
D - Convert to digits
Ṗ - Remove the last one
ƊÐƤ - Generate the suffixes of the digit list, then, for each:
S - Take the sum of the suffix
Ḍ - Convert the suffix back to a number
ḍ - Does the sum divide the number?
P - Is this true for all the suffixes?
DṖ Ḍ÷SƊẒ$ - 3. The right truncated integer is a strong Harshad number:
D - Convert to digits
Ṗ - Remove the last digit
$ - Group the previous two commands together:
Ɗ - Group the previous three commands together:
S - Take the sum of the digits
Ḍ - Convert back to an integer
÷ - Divide the integer by the sum
Ẓ - Is this number prime?
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/197321/edit).
Closed 4 years ago.
[Improve this question](/posts/197321/edit)
Is there any javascript-like language? Something that can be interpreted by browsers?
[Answer]
You can always try [JSF\*\*\*](https://esolangs.org/wiki/JSFuck) which allows any JavaScript program to be encoded using the characters `[]()!+`
Here's an example that prints `Hello, JavaScript!`
```
(+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+([][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[+!+[]]+[!+[]+!+[]+!+[]+!+[]]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][(![]+[])[+[]]+(!![]+[])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+((+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+[][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]]((![]+[])[+!+[]]+(+[![]]+[])[+[]])[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]]([!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]])+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][(![]+[])[+[]]+(!![]+[])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+((+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+[][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]]((![]+[])[+!+[]]+(+[![]]+[])[+[]])[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]]([!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]])+(!+[]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][(![]+[])[+[]]+(!![]+[])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+((+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+[][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]]((![]+[])[+!+[]]+(+[![]]+[])[+[]])[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]]([!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]])+([][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][(![]+[])[+[]]+(!![]+[])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+((+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+[][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]]((![]+[])[+!+[]]+(+[![]]+[])[+[]])[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]]([!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]])+(![]+[])[+!+[]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][(![]+[])[+[]]+(!![]+[])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+((+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+[][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]]((![]+[])[+!+[]]+(+[![]]+[])[+[]])[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]]([+!+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]])+(![]+[])[+!+[]]+(([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][(![]+[])[+[]]+(!![]+[])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+((+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+[][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]]((![]+[])[+!+[]]+(+[![]]+[])[+[]])[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]]([+!+[]]+[+!+[]]+[!+[]+!+[]])+(!![]+[])[+[]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][(![]+[])[+[]]+(!![]+[])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+((+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+[][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]]((![]+[])[+!+[]]+(+[![]]+[])[+[]])[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]())[(![]+[])[+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][(![]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]()+[])[!+[]+!+[]]](+!+[]+[+[]]+(+[![]]+[])[+[]])[+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[!+[]+!+[]]+(!+[]+[])[!+[]+!+[]+!+[]]]([!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]])+([][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!+[]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!+[]+[])[+[]]+(!+[]+[])[!+[]+!+[]+!+[]]+(!+[]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]])()
```
[Answer]
There's *J5h\*t* ([proposed](https://codegolf.stackexchange.com/questions/110648/fewest-distinct-characters-for-turing-completeness?page=1&tab=votes#comment270248_111002) name) which is [a Turing complete subset of JavaScript](https://codegolf.stackexchange.com/a/111002/43319), using only the characters
# `[]+=``
] |
[Question]
[
## This challenge is a harder version of [this one](https://codegolf.stackexchange.com/questions/71924/bijective-mapping-from-integers-to-a-variable-number-of-bits).
A variable number of trits is an array of 0 or more trits (a trit is a [ternary](https://en.wikipedia.org/wiki/Ternary_numeral_system) digit). So `[0, 2, 2, 1]` is a variable number of trits, but so is `[]`.
Write a function or program that, given an non-negative integer returns a variable number of trits such that every integer has a one-to-one (bijective) mapping with an array.
There are an infinite amount of such mappings, you are free to construct one as you please, but it **must** be one-to-one. Your mapping must *conceptually* be one-to-one for an arbitrarily sized integer, but it's OK if your *implementation* fails for large integers due to numerical limits of types in your preferred language (e.g. C's `int`).
As an example of what is **not** a one-to-one mapping, is simply listing the ternary digits of the integer. In such a system 5 becomes `[1, 2]` (because `1*3^1 + 2*3^0 = 5`), but it's not one-to-one, because `[0, 1, 2]` also means 5 (because `0*3^2 + 1*3^1 + 2*3^0 = 5`).
It should be fairly obvious that a mapping is not one-to-one if it skips an integer (e.g. it doesn't work for 5), but I'd like to make it clear that skipping a variable trit array is also not one-to-one. You must map to every possible variable trit array, including `[]`.
### Bonus challenge
You will be awarded the official Super Smaht® Award™ if your answer includes an algorithm (not necessarily in your golfed program) that not only works for base 2 or 3, but for all bases.
---
Shortest code in bytes wins.
[Answer]
# Pyth, 6 bytes
```
tjyhQ3
```
Explanation:
```
Q Input number.
h Add 1.
y Multiply by 2.
j 3 Convert to base 3 as a list.
t Remove the first element.
```
[Test suite](https://pyth.herokuapp.com/?code=tjyhQ3&test_suite=1&test_suite_input=0%0A1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19)
## Inverse function: Pyth, 14 bytes
```
t/i+-2%sQ2Q3 2
```
Explanation:
```
Q Input list.
s Sum.
% 2 Modulo 2.
-2 Subtract from 2.
+ Q Prepend to input list.
i 3 Convert from base 3.
/ 2 Divide by 2.
t Subtract 1.
```
[Test suite](https://pyth.herokuapp.com/?code=t/i%2B-2%25sQ2Q3%202&test_suite=1&test_suite_input=[]%0A[1]%0A[0]%0A[2]%0A[0,%201]%0A[1,%200]%0A[1,%202]%0A[2,%201]%0A[0,%200]%0A[0,%202]%0A[1,%201]%0A[2,%200]%0A[2,%202]%0A[0,%200,%201]%0A[0,%201,%200]%0A[0,%201,%202]%0A[0,%202,%201]%0A[1,%200,%200]%0A[1,%200,%202]%0A[1,%201,%201])
The bijection looks like this:
```
0: []
1: [1]
2: [0]
3: [2]
4: [0, 1]
5: [1, 0]
6: [1, 2]
7: [2, 1]
8: [0, 0]
9: [0, 2]
10: [1, 1]
11: [2, 0]
12: [2, 2]
13: [0, 0, 1]
14: [0, 1, 0]
15: [0, 1, 2]
16: [0, 2, 1]
17: [1, 0, 0]
18: [1, 0, 2]
19: [1, 1, 1]
⋮
```
# General base
To make this work in any base b, simply replace `3` with b, `2` with (b − 1), and `y` with `*`(b − 1).
[Answer]
# JavaScript, 24 bytes
```
f=n=>n?f(--n/3|0)+n%3:''
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEtLshMSS3Kzc/LTq38/z/NNs/WLs8@TUNXN0/fuMZAUztP1dhKXf1/Wn6Rgkamgq2CgbVCpoKirYKRqRmQpa2tqZCcn1ecn5Oql5OfDlShraD@qG2SOpBO08jU1LT@DwA "JavaScript (SpiderMonkey) – Try It Online")
Implements [the standard ternary bijective numeration](https://en.wikipedia.org/wiki/Bijective_numeration#Definition), except with the digits reduced by 1.
How it works: First, check if `n` is 0, returning the empty string if so. Otherwise, `n` is pre-decremented, and that value is divided by 3 and rounded down (`|0` is a short way to do the rounding) and passed recursively to `f` – the final digit will contribute 1, 2, or 3, while the rest contribute a multiple of 3, so \$\lfloor\frac{n-1}{3}\rfloor\$ is the value the non-final digits should represent on their own. Finally, `n%3` appends the final digit, reduced by 1 from the standard (`n` having already been decremented).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
ḃ3’
```
[Try it online!](https://tio.run/##y0rNyan8///hjmbjRw0zgfS2w@2PmtYcnfRw5wwgHfn/v7ERAA "Jelly – Try It Online")
```
ḃ3 Convert to bijective base 3
’ Decrement all digits
```
## Inverse, 3 bytes
```
‘ḅ3
```
[Try it online!](https://tio.run/##TY@xDYAwDAT7TMEAKWwzTpSSBmUBOoSEWIEhGICeScgiRgmW3o2tnE6f9zyVsqjW9XzvfdTnqNulmkLKMSRqg9uQ/owD2WbbnbNxNs7GxbgYF@MtB1EujSCw@wsCQxAI4vq4SmhFKOY6@9oQGIJAEHeau@4X8gc "Jelly – Try It Online")
```
‘ Increment all digits
ḅ3 Convert from base 3
```
Both versions can be made to use an arbitrary base by removing the `3`.
[Answer]
# Jelly, 12 bytes
```
ḤR‘b3Ḣ’$Ðḟị@
```
There is no empty list in Jelly; it is represented as `0` (an integer not a list).
For other bases: change `Ḥ` to `×n` and `b3` to `bn`, where `n` is the intended base.
[Try it online!](http://jelly.tryitonline.net/#code=4bikUuKAmGIz4bii4oCZJMOQ4bif4buLQA&input=&args=Mjc)
[Test suite.](http://jelly.tryitonline.net/#code=4bikUuKAmGIz4bii4oCZJMOQ4bif4buLQArDh-KCrA&input=&args=MCwxLDIsMyw0LDUsNiw3LDgsOSwxMCwxMSwxMiwxMywxNCwxNSwxNiwxNywxOCwxOSwyMCwyMSwyMiwyMywyNCwyNSwyNiwyNw)
# For other bases
It only costs **11 bytes** if given base as second input.
[Try it online!](http://jelly.tryitonline.net/#code=w5dS4oCYYuG4ouKAmSTDkOG4n-KBuOG7iw&input=&args=Mjc+NA)
[Test suite.](http://jelly.tryitonline.net/#code=w5dS4oCYYuG4ouKAmSTDkOG4n-KBuOG7iwrDp-KCrA&input=&args=MCwxLDIsMyw0LDUsNiw3LDgsOSwxMCwxMSwxMiwxMywxNCwxNSwxNiwxNywxOCwxOSwyMCwyMSwyMiwyMywyNCwyNSwyNiwyNw+NA)
# Algorithm
I thought of appending a `1` before the list and then convert it to a ternary.
That way, `[0,0]` will become `100 = 9` while `[0,0,0]` will become `1000 = 27`.
However, a problem arises: that `2011` and `1011` both map to `[0,1,1]`.
I only need [numbers whose ternary representation starts with `1`](http://oeis.org/A132141).
Therefore, I generated those whose ternary representation starts with `1`, and then use their **index** instead.
That is, the list begins as `[1, 3, 4, 5, 9, 10, 11, 12, 13, 14, 15, 16, 17, ...]`.
Therefore:
* `1` will be mapped to `1`
* `2` will be mapped to `3`
* `3` will be mapped to `4`
* `4` will be mapped to `5`
* `5` will be mapped to `9`
* `n` will be mapped to `a(n)` where `a` is that list.
There's another problem: both `0` and `1` are mapped to the empty list. Therefore, I removed `1` from the list, making `a = [3, 4, 5, 9, 10, 11, 12, 13, 14, 15, 16, 17, ...]`.
Those are the integers whose ternary representation starts with `1`, **except `1`**.
The same algorithm can be applied to other bases.
[Answer]
# Jelly, 6 bytes
```
‘Ḥb3ṫ2
```
Translation of [Kaseorg's answer in Pyth](https://codegolf.stackexchange.com/a/78998/48934).
[Try it online!](http://jelly.tryitonline.net/#code=4oCY4bikYjPhuasy&input=&args=Mjc)
Hardcoded base: [try it online!](http://jelly.tryitonline.net/#code=4oCYw5czYjThuasy&input=&args=Mjc)
Given base: [try it online!](http://jelly.tryitonline.net/#code=4oCYw5figbTigJnCpGLhuasy&input=&args=Mjc+NA)
[Answer]
# CJam, 9 bytes
```
ri)_+3b(;
```
Translation of [Kaseorg's answer in Pyth](https://codegolf.stackexchange.com/a/78998/53386).
[Try it online!](http://cjam.tryitonline.net/#code=cmkpXyszYig7&input=MTk)
[Answer]
## JavaScript (ES6), 31 bytes
```
n=>(n*2+2).toString(3).slice(1)
```
Since everyone else is translating @AndreasKaseorg's fine answer. Generic version (36 bytes):
```
b=>n=>(-~n*~-b).toString(b).slice(1)
```
] |
[Question]
[
## The challenge
In the least number of source code characters, in a language of your choosing, devise a function which raises base *a* to power *b*, modulo *m*, using purely integer arithmetic, where *a*, *b*, and *m* are all unsigned 64-bit values or larger. You may use signed arithmetic if your language does not have unsigned arithemetic.
This is the standard number-theory operation *a*^*b* (mod m), and not *a*^(*b* mod *m*).
Conceptually, and perhaps literally, depending on your implementation, all of your intermediate results should conform to the modulus *m*. That is to say, you won't actually be raising *a* to the *b* power and *then* computing the remainder after dividing by *m* — that would require as much as two trillion gigabytes of RAM to store a number that big. Instead, you'll be raising *a* to the *b* power *while* staying within the constraints of modulus *m*, or straying from it only a bit (no pun intended).
This is actually a lot easier than it sounds!—Raising numbers to astronomically large powers can actually be a surprisingly fast operation. If you do it right, you can compute the result in a handful of microseconds, or perhaps few milliseconds if you're using a slow language. However, you are free to use any algorithm you like, even if it uses an increment-counter in a hard loop running for quadrillions of years. The only requirement with regard to execution time is that your program provably halt in a finite amount of time, providing the correct answer.
## Input assumptions
You can assume that *a* ≥ 0, *b* ≥ 0, m > 0, and *a* < *m*, but you should not assume that *b* < m. That is, you should assume that both *b* and *m* can be any value as large as your integer type supports (this will be 2⁶³–1 for signed 64-bit integers and 2⁶⁴–1 for unsigned 64-bit integers).
If you are given *a* = *b* = 0, you can return whatever value you like, since 0^0 is undefined. Similarly, if you are given m = 0, you can return whatever you like, since 0 is not a valid modulus.
## Test values
Your program should work correctly for all inputs, but here are a few samples to help you with validation:
```
Base Exponent Modulus Result
2 8 255 1
2 8 256 0
2 8 257 256
3 7 10000 2187
2 2046 2047 1
123 456 789 699
3 1000 18446744073709551615 12311760789144243126
86400 22157322 48519018006822 40149207423504
8675309 100018327824 8621993634251008000 3858055581225668161
325284989554104320 1508436685178379520 8582294829391072256 6354230931838838784
```
**Counting source characters**
Spaces and tabs each count as 1 character. Newlines do not count, unless the newline character adds syntactic whitespace in order to permit parsing. For example, the newline at the end of the first line here counts as 1 character because it is required to permit proper parsing:
```
#define foo 7
int f(){...}
```
But the newline character at the end of the first line here does not count:
```
int f(){...}
int g(){...}
```
because parsing would still be possible if the two lines were adjoined:
```
int f(){...}int g(){...}
```
This allows you to present your source code with line-breaks at natural locations without penalty, so that you don't have to try to cram everything onto a single line. Finally, if you're using C/C++ and you put a `\` at the end of a line, then the newline also does not count because you're using the `\` only for readability of presentation.
**Restrictions & Allowances:**
1. Arithmetic: You may use only integer addition, subtraction, logical operations, and conditionals. Comparisons count as a form of subtraction. Multiplication and division are not allowed. (However, the specific case of left- and right-shifting may be written using `*2`, `*=2`, `/2`, `/=2` if these are syntactically shorter than the bit-shifting operators in your language, e.g., `<<1`, `<<=1`, `>>1`, `>>=1`, etc.) Use of a built-in exponentiation operator (e.g., `**`) is not allowed.
2. Floating-point arithmetic is not allowed. However, you may use floating-point variables provided you only use them to hold integers. (Floating-point operations aren't really going to help you on this challenge anyway, so don't be discouraged by this restriction.)
3. Your function is not required to have a name (it can be an anonymous or lamba function if your language supports that), but it does have to be a bona fide function that you can call an arbitrary number of times.
4. No global variables. (Exception: If there is no way in your language to provide a solution without global variables, then you may use global variables. But *only* if there is no other way.)
5. You may ignore any and all compiler, interpreter, or runtime warnings, so long as your program computes correct results.
6. If you are using a language which requires importation of type declarations in order to guarantee a 64-bit integer size (e.g, `<stdint.h>` in C), you may assume that this is already included. Note that `uint64_t` is considerably fewer characters than `unsigned long long`.
**Cheating:**
1. You may optionally provide a cheat solution, but only if you are *also* providing a legal solution *and* your cheat solution computes correct results as well (please post the cheat version below the legal version and do not count the cheat version as your score).
2. If you do provide a cheat version that uses a built-in exponentiation operator or function call (e.g., `**` in AWK or `pow()` in C), beware of rounding and truncation issues. Just because you're providing a cheat version doesn't mean you're allowed to produce incorrect results. :-) For example, writing `uint64_t modpow(uint64_t a,uint64_t b,uint64_t m){return pow(a,b)%m;}` in C hasn't even the remotest chance of being correct for anything but the smallest values, so don't do that. (Actually, it might even be a challenge *to* use built-in non-modular exponentiation. I'd be interested to see if anyone actually manages to pull that off. But even though I'm posing that as a sub-challenge, it's still considered a cheat for the purposes of the larger challenge.)
**If you need help getting started:**
Here are a couple resources with simple algorithms for computing modular exponentiation:
1. [Modular exponentiation [Wikipedia.org]](http://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method)
2. [Fastest modular exponentiation [CodeGolf.StackExchange.com]](https://codegolf.stackexchange.com/questions/12744/fastest-modular-exponentiation)
**Lastly:**
I will be posting a solution in C99 that I worked out earlier today as a byproduct of writing a Miller–Rabin primality test for another purpose. My answer should not be treated as an eligible entry to the challenge.
I am really looking forward to seeing what you come up with in Golfscript, Befunge, Haskell, Clojure, and more!
[Answer]
# Python 2 (70)
```
def f(a,b,m,n=1):
exec("n=0"+"+n"*a+";")*b
while n>=m:n-=m
return n
```
Very, very slow. The multiplications are string operations, not arithmetic ones, so I hope they're allowed.
The line with `exec` generates and executes code like (with `a=4`, `b=3`):
```
n=0+n+n+n+n;n=0+n+n+n+n;n=0+n+n+n+n;
```
Edit: Here's two alternative solutions that use list/string multiplication in a cheaper way by representing the current number as a list of ones. They're both exactly the same length as the original (70 chars).
```
def f(a,b,m,s=[1]):
exec"s*=a;"*b;n=len(s)
while n>=m:n-=m
return n
```
```
def f(a,b,m,s=[1]):
exec"s*=a;"*b
while s[m:]:s=s[m:]
return len(s)
```
More edit: A 66-char solution that uses string splitting to do the modulo m
```
def f(a,b,m,s="1"):
exec"s*=a;"*b
return len(s.split("1"*m)[-1])
```
and a 65-char recursive one-liner
```
f=lambda a,b,m:b and len((a*f(a,b-1,m)*"1").split("1"*m)[-1])or 1
```
[Answer]
## Haskell (78)(67)(61)
```
p a b m|b==0=1|0<1=until(<m)(+(-m))$sum$replicate a$p a(b-1)m
```
The function f is a simple modulus function implemented using repeated subtraction.
The modular exponentiation function `p` first tries to match `b==0`. If this is true, then it returns 1. Otherwise, it calls `p` recursively, "multiplies" it with `a`, and reduces it `mod m`.
It work with all the inputs until `p 86400 22157322 48519018006822`, where the stack overflows.
**EDIT**: Thank's Matt! Using Matt's idea, I was able to shorten the mod function and have it in place. Still overflows though.
**EDIT**: Realized foldl(+)0 is just a sum. Doh!
[Answer]
# Haskell: 87 bytes
Performs modular exponentiation *x**y* mod *n* in a number of operations which is logarithmic in the exponent *y*. The code
```
(x!y)m|odd y=z q|y>0=q|0<1=1where z 0=0;z n=until(<m)(+(-m))$x+z(n-1);q=(z x!div y 2)m
```
defines an operator (!) to do modular exponentiation, so you can use it like
```
(2!3) 5 == 3
```
The program works by using the two relations *x*2 *n* = (*x*2)*n* and *x*2 *n* + 1 = *x* (*x*2)*n* to accumulate the result, halving the exponent at each step. Intermediate results are taken mod *m* by repeated subtraction. Here's an ungolfed version:
```
(x ^% y) m
| y == 0 = 1
| odd y = x `times` (squaredX ^% halfY) m
| otherwise = (squaredX ^% halfY) m
where squaredX = x `times` x
halfY = y `div` 2
a `times` 0 = 0
a `times` b = reduce $ a + a `times` (b - 1)
reduce n = if n < m then n else reduce (n - m)
```
*Note:* div is used to carry out a right shift operation only.
[Answer]
## Javascript (92) 89
```
function f(a,b,m){
c=1;
while(b--){
o=0;
for(i=0;i<a;i++){
o+=c-m;
if(o<0)
o+=m;
}
c=o;
}
return c;
}
```
Thanks to Todd for the while loop trick. I didn't know Javascript could do that.
Each iteration through the outer loop "multiplies" the result by a. Essentially it adds the previous iteration's result to itself a times (i.e. multiplying itself by a). It also subtracts m each time, and if it's less than 0, it adds it back.
This function is not very efficient, especially for large inputs, but it should eventually return the correct response.
[Answer]
## C, 175 characters
Answering my own question. This answer should not be considered an eligible entry to the challenge.
```
#define N uint64_t
#define X(F,G,d)\
N F(N m,N a,N b){N c=d;for(;b;b/=2){if(b&1)c=G(m,c,a);a=G(m,a,a);}return c;}
N A(N m,N a,N b){return a+=b,a-(a<m&&a>=b?0:m);}X(M,A,0)X(E,M,1)
```
***How it works:***
The macro invocation `X(E,M,1)` generates a function `E(m,a,b)`, and the invocation `X(M,A,0)` generates a function `M(m,a,b)` using the same macro template with slightly different parameters.
`E(m,a,b)` is the modular Exponentiation function. It calls the modular Multiplication function `M(m,a,b)`, which in turn calls the modular Addition function `A(m,a,b)`. The modular addition function has subtle logic to detect and handle both 64-bit overflow and modular overflow correctly, which is transparently leveraged by the higher-level functions.
***Performance:***
Worst-case performance of this is approximately (log₂*m*)² steps, or about 4096 steps for large 64-bit *m*.
Runtime on a 3.4 GHz Intel Core i7 to compute 1 million different values of
>
> a ^ 18446744073709551615 (mod 18446744073709551615)
>
>
>
for *a* ∈ [1,10⁶] is 51.8 seconds, or 51.8 microseconds per exponentiation invocation, where 18446744073709551615 = 2⁶⁴ – 1, which is the most taxing 64-bit value for this method.
At the other end of the spectrum, using much smaller values, the runtime to compute 1 million different values of
>
> a ^ a (mod 2a + 1)
>
>
>
for *a* ∈ [1,10⁶] is only 3.41 seconds, or 3.41 microseconds per exponentiation operation.
---
## C, 110 characters
Here is formulation using nested loops:
```
#define N uint64_t
N E(N M,N A,N B){N C=1;while(B--){N c=0,a=A;while(a--)c+=C,c>=M||c<C?c-=M:0;C=c;}return C;}
```
***How it works:*** The capital variables A, B, and M are the original values passed in; the lowercase variables c and a are temporary work variable copies of their uppercase counterparts. The inner loop performs repeated addition to produce multiplication. The outer loop performs repeated multiplication (using the inner loop) to produce exponentiation.
***Performance:*** This formulation is reasonably fast for very small input values, but performs extremely poorly for even moderately large values. The runtime is proportional to the product of *a* and *b* and is independent of *m*; in other words, this is an O(*ab*) algorithm. Worst-case performance on 64-bit input is 2¹²⁸ steps, which on my system would require 4.2 × 10²⁹ seconds or about 13 thousand million million million years. For worst-case input, this is 10³⁴ times slower than the more efficient version earlier.
] |
[Question]
[
Your task is to format an address given in all lowercase to a friendlier format. Here's the catch, **no regexes**.
Addresses will be given in the following format:
`123 serpentine pl ne shoreline wa 98199`
The expected output is the following: (notice the period and commas)
`123 Serpentine Pl. NE, Shoreline WA, 98199`
**Formatting Rules**
* Cardinal directions should be capitalized, e.g. "e" --> "E", "nw" -->
"NW".
* Abbreviations for streets, avenues, etc. should have the first letter
capitalized with the abbr. followed by a period (".") e.g "st" --> "St.", "ave" --> "Ave.".
* State abbreviation should be in all caps
* A comma is placed after each section. i.e. after the street address and state and city.
* Capitalize the city and street/avenue/place.
**EDIT**:
Addresses will always be given in the above format *except* with or without a cardinal direction.
Your code should also be able to handle "st" and "ave". The input is given through `stdin`. This is code-golf so the shortest code in bytes wins.
[Answer]
# Perl 6: ??? characters
The simplest Perl 6 solution is probably: (*61 characters*)
```
$/=get.wordcase.words;"$0 $1 $2. $3.uc(), $4 $5.uc(), $6".say
```
Unfortunately, I don't feel comfortable using this, since `.wordcase` and `.words` are both implemented internally using regexes. Thus: (also, oddly, *61 characters*)
```
$/=get.split(' ')».tc;"$0 $1 $2. $3.uc(), $4 $5.uc(), $6".say
```
BUT this only handles the specific address given in the problem. Consider:
```
42 awesome ln dogeland hi 96899
```
I see this as valid under to be formatted given the rules above, and this should be formatted as `42 Awesome Ln., Dogeland HI, 96899` rather than `42 Awesome Ln. DOGELAND, Hi 96899,`. So let's fix the case that a cardinal direction isn't included: (*136 characters*)
```
my@a=get.split(" ")».tc;@a[3].=uc if @a[3] eq tc any "n","s","" X~ "e","w","";@a[2]~=".";say "@a[0..*-4], @a[*-3] @a[*-2].uc(), @a[*-1]"
```
[Answer]
# Lua - 462
```
_=_G d={n=_,nw=_,sw=_,s=_,se=_,e=_,ne=_,al=_,ak=_,az=_,ar=_,ca=_,co=_,ct=_,de=_,dc=_,fl=_,ga=_,hi=_,id=_,il=_,["in"]=_,ia=_,ks=_,ky=_,la=_,me=_,md=_,ma=_,mi=_,mn=_,ms=_,mo=_,mt=_,nv=_,nh=_,nj=_,nm=_,ny=_,nd=_,oh=_,ok=_,["or"]=_,pa=_,ri=_,sc=_,sd=_,tn=_,tx=_,ut=_,vt=_,va=_,wa=_,wv=_,wi=_,wy=_}l={pl=_,st=_,ave=_,hw=_}print((io.read"*a":gsub("%w+",function(x)if d[x]then return x:upper()..","end return x:sub(1,1):upper()..x:sub(2):lower()..(l[x]and"."or"")end)))
```
The first is a list of states and directions, the second is a list of places.
One might argue that gsub is using regular expressions, but lua uses *patterns*, that are close, but not exactly are regexes. They cannot match regular languages and don't even have a proper Klenee star.
Example:
```
$ lua % <<< '123 serpentine pl ne shoreline wa 98199'
123 Serpentine Pl. NE, Shoreline WA, 98199
```
[Answer]
# Javascript
```
b="123 serpentine pl ne shoreline wa 98199".split(" ");
c=[];
cap = function(l){var code=parseInt(l.charCodeAt(0));if(code>=97&&code<=122){l=String.fromCharCode(code-32);}return l;}
c[0]=b[0];
c[6]=b[6];
b.forEach(function(txt,index){
tx=txt.split("");
switch(index){
case 1:case 4:tx[0]=cap(tx[0]);c[index]=tx.join("");break;
case 2:case 3:case 5:tx.forEach(function(t,idx){
tx[idx]=cap(t);
});
c[index]=tx.join("");
break;
}
});
//now
output=c[0]+" "+c[1]+" "+c[2]+". "+c[3]+", "+c[4]+" "+c[5]+", "+c[6];
```
[Answer]
# Python3 ~~137~~ 122
```
i=input().split()
c=lambda x:x.capitalize()
print(i[0],c(i[1]),c(i[2])+".",i[3].upper()+",",c(i[4]),i[5].upper()+",",i[6])
```
```
>python main.py
123 serpentine pl ne shoreline wa 98199 #Pasted
123 Serpentine Pl. NE, Shoreline WA, 98199 #Output
>
```
[Answer]
# Python2
(based on other python3 answer)
```
i=raw_input().split()
i=map(lambda x:x.capitalize(),i)
print " ".join((i[0],i[1],i[2]+".",i[3].upper()+",",i[4] ,i[5].upper()+",",i[6]))
```
running in Windows cmd
```
C:\Python27>python main.py
123 serpentine pl ne shoreline wa 98199 #Pasted
123 Serpentine Pl. NE, Shoreline WA, 98199 #Output
```
[Answer]
# Powershell v4
```
$h=Read-Host
$i=(Get-Culture).TextInfo.ToTitleCase($h).Split()
($i[0..2 ] -join " ")+". "+$i[-4].ToUpper()+", "+$i[-3]+" "+$i[-2].ToUpper()+",",$i[-1]
```
running
```
C:\>powershell .\address.ps1
123 serpentine pl ne shoreline wa 98199 #Pasted
123 Serpentine Pl. NE, Shoreline WA, 98199 #Output
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 10 years ago.
[Improve this question](/posts/11530/edit)
Problem:
Take input text like this: (all input should be considered strings)
```
Upi djpi;f ytu yu[omh pmr yp yjr ;rgy.
```
And figure out if it was offset left or offset right (on a standard qwerty keyboard as pictured below).
Also only keys that output something to the screen are considered valid, so these keys: caps, shift, tab, enter, delete(backspace), should not be considered when doing this challenge.
Once you have figured out what the offset is, print out the offset and the correct text.
For example the above input would have this output
```
text: You should try typing one to the left.
offset: right
```
Your program has to *'know'* that the sentence is correct before it prints out. (so no asking for user verification). Also no using libraries (should be a given).
All input will begin with a capital and end in a period (the period will not be offset left or right so you won't be able to use it to determine the offset.)
Another example:
```
U kujw oeife'nnubf xibrwara.
I like programming contests.
```
Some input samples to use:
```
X'ra 'bs sifa 'ew ai o'aaw.
Yjod vpmysod sm stnoysto;u ;pmh eptf.
Rgw x'r ;b rgw g'r qwbr iyr ri v'r.
Og upi vtrsyr s d,s;; fovyopmstu pg yjr ,pdy vp,,pm rmh;odj eptfd yjrm upi vsm vjrvl upit piy[iy gpt yjpdr eptfd' yjr eptf ayjra smf yjr eptf asmfa str imowir ejrm pggdry ;rgy smf pggdry tohjy. //<< don't put this deciphered text in your answers.
```
And **bonus** option: write your program to be able to handle the input switching offsets.
Example above with switching offset:
```
Upi djpi;f ytu yu[omh ibw ri rgw kwdr.
text: You should try typing one to the left.
offset: right -> index[21], then left.
```
Winning criterion:
* Faster code gets more points (out of 10) so O(logn) would score more then O(n^2) solutions (obviously).
* Elegance (out of 20) There is a very elegant and simple solution to this problem. The closer you get to the simple solution the higher your score. (bonus +5 if you think of something simpler then my solution).
* This is not a code golf, but concise readable code will be scored (out of 10).
* Bonus is all or nothing for 5 extra points.
So A perfect score would be 40 but you could score up to 50 if you get both bonuses.
bonus +2 if you read *all* instructions
[Answer]
## Python
The original version didn't deal with punctuation too well, so here's a revised version.
```
r = dict(zip('\\qwertyuio\'asdfghjkl;/zxcvbnm|:"?', 'qwertyuiopasdfghjkl;\'zxcvbnm,Q"AZ'))
l = dict(zip('wertyuiop[\'asdfghjkl;xcvbnm,.{:"<', 'qwertyuiop;\'asdfghjklzxcvbnm,PL:M'))
shifts = {'right': r, 'left': l}
def shift(ciphered):
letters = set(ciphered)
if letters & set('p[{,<') or any(i in ciphered for i in ('yjr', 'smf')):
return 'left'
elif letters & set('qz\\|/?') or any(i in ciphered for i in ('rgw', '\'bs')):
return 'right'
else:
return 'right' if ciphered.count('w') > ciphered.count('y') else 'left'
def decipher(ciphered):
ciphered = ciphered.split('.', 1)[0].lower()
shift_ = shift(ciphered)
text = ''.join(shifts[shift_].get(i, i) for i in ciphered).capitalize()
print 'text:', text + '.'
print 'offset:', 'left' if shift_ == 'right' else 'right'
decipher(raw_input())
```
This is how it works:
* If any of the characters `p[{,<` are in the ciphered string, or `yjr` or `smf` (`the` and `and` shifted right respectively) are in the string, then the string must have been shifted right.
* If any of the characters `qz\|/?` are in the ciphered string, or `rgw` or `'bs` (`the` and `and` shifted left respectively) are in the string, then the string must have been shifted left.
* If neither of the above are true, then we compare the counts of `'w'` and `'y'` in the string. If there are more `'w'`s, then it is most likely to have been shifted left, because `'e'` is more common than `'u'` in English. If not, then it probably would have been shifted right, since `'t'` is much more common than `'q'` in English.
+ The original function used `'w'` and `'s'`, however using `e/u` and `q/t` will theoretically produce much stabler results, as the frequency differences between the letter pairs are higher than those of the original `e/d` and `q/a`.
+ This will work for most strings, however theoretically there might be some strings who will give the wrong output. (If you find one, post the offender in the comments and I will try to make the test more stable)
* We reverse-shift the string accordingly, to produce the output.
Note that if there is a comma in a string that has been shifted right (ie there is a `.` in the ciphered string excluding the one at the end), then this will not work, as the function only deciphers the part before the first period in the string.
[Here](http://ideone.com/15t0BC) are some sample test results.
[Answer]
## Tcl
```
set right {q w w e e r r t t y y u u i i o o p p {[} {[} \] \] q Q W W E E R R T T Y Y U U I I O O P P {[} {[} \] \] Q a s s d d f f g g h h j j k k l l {;} {;} ' ' a A S S D D F F G G H H J J K K L L {;} {;} ' ' A \\ z z x x c c v v b b n n m m , , \\ \\ Z Z X X C C V V B B N N M M , , \\}
set left {q \] w q e w r e t r y t u y i u o i p o {[} p \] {[} Q \] W Q E W R E T R Y T U Y I U O I P O {[} P \] {[} a ' s a d s f d g f h g j h k j l k {;} l ' {;} A ' S A D S F D G F H G J H K J L K {;} L ' {;} \\ , z \\ x z c x v c b v n b m n , m \\ , Z \\ X Z C X V C B V N B M N , M}
gets stdin data
set len [string length $data]
set min 0
set res {}
foreach {d} {left right} {
set trans [string map [set $d] $data]
if {[string first " and " $trans] > 0 || [string first " the " $trans] > 0} {set v 1} {
if {[regexp {[\]\[]} $trans]} {continue}
set vocals [regexp -all -nocase {[aeiou]} $trans]
set v [expr {($vocals * 1. / $len)}]
}
if {$v > $min} {
set res "$trans\noffset: $d"
set min $v
}
}
puts $res
```
I build a map to replace the characters with the next.
If there are strange characters in the output, I'll reject it.
As last chance I take the highest vocal/length count.
I claim the +2
[Answer]
## Lua
The idea is to determine which group of letters is prevailing: ABIUW or JOPY.
The former has frequent letters on next key to the right on the keyboard, the latter - to the left.
```
local strings = [[
Upi djpi;f ytu yu[omh pmr yp yjr ;rgy.
U kujw oeife'nnubf xibrwara.
X'ra 'bs sifa 'ew ai o'aaw.
Yjod vpmysod sm stnoysto;u ;pmh eptf.
Rgw x'r ub rgw g'r qwbr iyr ri v'r.
Og upi vtrsyr s d,s;; fovyopmstu pg yjr ,pdy vp,,pm rmh;odj eptfd yjrm upi vsm vjrvl upit piy[iy gpt yjpdr eptfd' yjr eptf ayjra smf yjr eptf asmfa str imowir ejrm pggdry ;rgy smf pggdry tohjy.
]]
for str in strings:gmatch'%C+' do
str = str:lower()
-- compare total counters of letters ABIUW and JOPY
local _, left_ctr = str:gsub('[abiuw]','')
local _, right_ctr = str:gsub('[jopy]','')
local offset = left_ctr - right_ctr
offset = offset / math.abs(offset) -- offset == (+1) or (-1)
-- restore original string
local original = ''
local keyboard = "asdfghjkl;'?zxcvbnm,'qwertyuiop['"
for c in str:gmatch'.' do
local pos = keyboard:find(c, 1, true)
c = pos and keyboard:sub(pos + offset, pos + offset) or c
original = original..c
end
print('text: '..original:sub(1,1):upper()..original:sub(2))
print('offset: '..({[-1]='right', 'left'})[offset])
print()
end
```
---
Output:
```
text: You should try typing one to the left.
offset: right
text: I like progr?mming contests.
offset: left
text: C?ts ?nd dogs ?re so p?sse.
offset: left
text: This contais an arbitarily long word.
offset: right
text: The c?t in the h?t went out to b?t.
offset: left
text: If you create a small dictionary of the most common english words then you can check your output for those words; the word the and the word and are unique when offset left and offset right.
offset: right
```
[Answer]
# Haskell
Certainly not the fastest or smallest one, but at least now there is a Haskell solution!
## The idea
1. Write in the code the configuration of the `keyboard`, one string per keyboard line
2. Generate `left` and `right` shifted keyboard and build dictionaries of keys correspondences
3. Create a `ShiftString` method that convert a string with `right` or `left` dictionary
4. Write an `englishProb` function that compute the *least square* between frequency of a given string and the english language frequencies
5. Implement a method `chooseShift` that convert a string to `left` and `right` shifted sentences, compute the englishProb on them and return the dictionary minimizing the least square error
6. Write a `solve` method that take a string, choose the best dictionary, convert the sentence with it, and format the output as desired
7. Create the `main` function that use `solve` on input
## The code
```
import Data.Char
import Data.List
main :: IO()
main = do
content <- getContents
putStr . unlines . map solve . lines $ content
solve :: String -> String
solve s = "text:" ++ shiftString shift sc ++ ".\noffset: " ++ offset shift
where sc = takeWhile (/='.') s
shift = chooseShift sc
offset sh | sh == left = "left"
| sh == right = "right"
| otherwise = "unknown"
chooseShift :: String -> [(Char, Char)]
chooseShift s = if (englishProb lefted >= englishProb righted) then left else right
where lefted = shiftString left $ map toLower s
righted = shiftString right $ map toLower s
englishProb :: String -> Double
englishProb s = squaredDiff stats
where stats = map (\a@(x:_) -> (x,normalize $ length a)) . group . sort $ s
normalize a = (fromIntegral a) / (fromIntegral $ length s)
squaredDiff p = sum . map ((\x -> x*x) . diff) . filter isAlpha $ p
diff (c,v) = abs . (v-) $ lookup' c letterFreq
isAlpha (a,_) = ord(a) >= 97 && ord(a) <= 122
keyboard :: [String]
keyboard = ["qwertyuiop[]\\", "asdfghjkl;'","zxcvbnm,./"," "]
right :: [(Char,Char)]
right = shiftKeyboardWith shiftR
where shiftR l = (tail l)++[(head l)]
left :: [(Char,Char)]
left = shiftKeyboardWith shiftL
where shiftL l = (last l):(init l)
shiftString :: [(Char,Char)] -> String -> String
shiftString m s = map (\c -> shiftChar c m) s
shiftChar :: Char -> [(Char, Char)] -> Char
shiftChar k d = reCast $ (\(Just b) -> b) $ lookup (toLower k) d
where reCast = if (isUpper k) then toUpper else id
shiftKeyboardWith :: ([Char] -> [Char]) -> [(Char,Char)]
shiftKeyboardWith f = zip (concat keyboard) . concat $ map f keyboard
lookup' :: (Eq a) => a -> [(a,b)] -> b
lookup' k d = (\(Just b) -> b) $ lookup k d
letterFreq :: [(Char, Double)]
letterFreq = [ ('a',8.167)
, ('b',1.492)
, ('c',2.782)
, ('d',4.253)
, ('e',12.702)
, ('f',2.228)
, ('g',2.015)
, ('h',6.094)
, ('i',6.966)
, ('j',0.153)
, ('k',0.772)
, ('l',4.025)
, ('m',2.406)
, ('n',6.749)
, ('o',7.507)
, ('p',1.929)
, ('q',0.095)
, ('r',5.987)
, ('s',6.327)
, ('t',9.056)
, ('u',2.758)
, ('v',0.978)
, ('w',2.360)
, ('x',0.150)
, ('y',1.974)
, ('z',0.074) ]
```
## Compilation
```
ghc shift.hs
./shift.hs < inputs
```
## Output
```
text: You should try typing one to the left.
offset: left
text: I like programming contests.
offset: right
text: Cats and dogs are so passe.
offset: right
text: This contais an arbitarily long word.
offset: left
text: The cat 'n the hat went out to bat.
offset: right
text: If you create a small dictionary of the most common english words then you can check your output for those words; the word 'the' and the word 'and' are unique when offset left and offset right.
offset: left
```
[Answer]
## Python 2.6 390 430 410 408 355 347 354 346 300 chars
**Updates**:
1. (Hopefully) fixed a bug with semicolons.
2. Horrible hack to make the middle row work properly :(
3. Golfed the hack a bit better
4. Fixed stupid printing
5. Realised I can assume left if not right!
6. Now deals with the whitespace in a much neater way. (after breaking it!)
7. Trimmed a bit all over
8. Changed the key condition for left or rightness
9. Changed some variable names and pruned the `lambda`
10. **Thanks to Volatility for some much neater ways to do things, and a general golf overhaul (see comments).**
11. Changed the letters it searches for to avoid redundancy (for instance the character `r` is likely to appear in all shifted sentences).
Golfed with help from Volatility. Algorithm compares the number of times the characters `'awg` and `mp;[y` appear in the text. The first set corresponds to `aoseh` shifted left, the second to `anolpt` shifted right. These unshifed letters are highly likely to appear in any sentence (each set should account for ~40% of the letters in a normal sentence) and are indicative of which shift occurred (the shifted letters are unlikely/forbidden to appear in the same sentence when shifted the other way).
To help with choosing which letters to use, I used the [frequency of each letter](http://en.wikipedia.org/wiki/Letter_frequency) to find the corresponding frequency of characters which appear in shifted sentences using this (slightly golfed for practice) [program](http://pastebin.com/YtzgUqQ3).
I don't think it handles punctuation very well for instance (commas?). Please leave comments with failure cases and I'll try to make it more robust :)
Usage
```
$ program.py
'Put text here with any escape characters if it\'s necessary.'
```
Code:
```
s=''.join(dict(zip('|{"?:<',"\['/;,")).get(x,x)for x in input().lower())
h=lambda b:sum(x in b for x in s)
i=h('mpsy;[')>h("'aiwg")
f=" \qwertyuiop[asdfghjkl;'/zxcvbnm,. "
t=''
for x in s:t+=f[f.find(x)+(1,-10)[x=="'a"[i]]*(-1)**i]
print'offset:',('righ','lef')[i]+'t\ntext:',t[:-1].capitalize()+'.'
```
**Explanation:**
* Ignore uppercase and replace "uppercase" symbols (ie capital "Q" shifted left is "|")
* Choose right if any characters from that small set, else right (this actually is sufficient for all the test cases!). Compare number of indicative 'left' and 'right' characters and chose left or right from this
* the shift string is as reduced as possible and as a result doesn't deal with the middle line wrapping around. 2 spaces at the start and 1 at the end deals with the whitespace
* deal with `'` if shifted left or `a` if shifted right by offsetting by 10 in the other direction. whitespace is found at index 0 in `s` so -1 or +1 match either 2nd or last character in s (both whitespace)
* print
**Failures:**
There are failure cases but the code will work with a very high probability if the sentence hasn't been specifically engineered to break it :)
>
> Boo proper nouns: `"\"b 'ookw dwkk ib Bwqrib;a gw's."`
>
> Right-shifted sentences without the letters `anoplt` but with some `'fqu`
>
> `"Wirrmd wirrg ypp."` fails whereas `"Wirrmd wirrg ypp upi lmpe."` succeeds (apologies)
> Left-shifted sentences without the letters `aeosh`
>
>
>
] |
[Question]
[
Have a look at my (javascript) version of a O(log(n)) xn algorithm:
```
function pow(x,n)
{
return n==0?1:n==1?x:n==2?x*x:pow(pow(x,(n-n%2)/2),2)*(n%2==0?1:x);
}
```
Can you get it shorter?
[Answer]
BrainFuck (482 characters)
Solution is modulo 256. Reads n in digit by digit. Each time it sees a new digit d, it raises the current value to the tenth power and then multiplies that by x^d
Input must be x followed by single space, followed by n, followed by newline
```
>,--------------------------------[--------------->,--------------------------------]<[<]>>[<-[->++++++++++<]>>]<->+>>>>>,----------[--------------------------------------<++++++++++<+>[-<[-<<<[->+>+<<]>[-<+>]>>]<[->+<]>>]<[-<+>]>>[-<<+>>]<<<<<[-]>>>[-<[-<<<[->+>+<<]>[-<+>]>>]<[->+<]>>]<[-<<+>>]>>>,----------]>>+<<+<<+<<+<<[-]>[->[>+----------[>-<[-<+>]]<-[->+<]+>++++++++++>]+<<[<----------<]>++++++++++]>[>++++++++++++++++++++++++++++++++++++++++++++++++>]<<<<[>.<<<]++++++++++.
```
[Answer]
If you don't mind using a global variable:
```
return n?(t=pow(x,n>>1))*t*(n%2?x:1):1
```
Through some ingenious trickery, Howard devised a clean alternative:
```
return n?(n%2?x:1)*(x=pow(x,n>>1))*x:1
```
And Peter Taylor managed to shave one character:
```
return(n%2?x:1)*(x=n?pow(x,n>>1):1)*x
```
Even shorter based on ratchet freak's idea:
```
return(n%2?x:1)*(n?pow(x*x,n>>1):1)
```
[Answer]
```
function pow(x,n)
{
return n==0?1:n==1?x:pow(x*x,n>>1)*pow(x,n&1);
}
```
removed the `n==2` case,
replaced the `(n-n%2)/2` with `n>>1` (you can also use `n&-2`)
used `x*x` instead of `pow(pow(...),2)`
replaced `*(n%2==0?1:x)` with `*pow(x,n&1)`
[Answer]
## GolfScript (29 chars as function, 24 chars as block)
```
{1@@2base-1%{{.@*\}*.*}/;}:P;
```
without the function wrapper that's
```
1@@2base-1%{{.@*\}*.*}/;
```
It's not recursive, but it is `O(lg n)` time, using the binary decomposition of `n`. Essentially it takes the fact that the recursive `pow` can be made tail-recursive with an accumulator and pushes that to its conclusion:
```
# Stack: a n
1@@
# Stack: 1 a n
2base
# Stack: 1 a [bits of n]
# Reverse the bits so that we loop over them starting at the least significant
-1%
# foreach
{
# Stack: accum x bit
# where accum = a^(n%(2^i)) and x = a^(2^i)
# If the bit is set, multiply the accumulator by x
{.@*\}*
# Square x
.*
}/
# Pop the unwanted a^(2^(2+lg n)) and we're left with a^n
;
```
(There is also the built-in `?` for one char, but I don't think that's in the spirit of this codegolf).
[Answer]
# GolfScript - 33
This feels awfully clumsy but here it goes:
```
{.2/.{2$\P}{;1}if.*@@1&{*.}*;}:P;
```
Usage: `2 11P` -> `2048`
(Thanks Peter Taylor)
[Answer]
## Java
```
int pow(int x, int n){
int t=1;
return n==0?1:(n%2==0?1:x)*(t=pow(x,n/2))*t;
}
```
And if `t` is an initialized class variable, you can remove the first line.
[Answer]
**C++, 44 characters**
```
int p(int x,int n){return !n?1:x*p(x,n-1);}
```
[Answer]
## k4 (38)
fairly straightforward port of the java solution
`{$[y;*/((y-2*r)#x),2#x .z.s/r:_y%2;1]}`
[Answer]
### Haskell, 49 characters
```
x^0=1;x^2=x*x;x^n|odd n=x*x^(n-1)|1>0=x^div n 2^2
```
readable version:
```
x^0 = 1
x^2 = x * x
x^n | odd x = x * x^(n-1)
| even x = x ^ (d`div`2) ^ 2
```
The idea to special-case x^2 shamelessly stolen from the asker.
Another 49-character version, requires common subexpression elimination (which GHCi doesn't do in this case) to be efficient:
```
x^0=1;x^n|odd n=x*x^(n-1)|1>0=x^div n 2*x^div n 2
```
[Answer]
In python we have 2 methods for doing this :
```
def p(x,n,l):
print pow(x,n,l)
def p1(x,n):
print x**n
p(10,5,52)
p1(10,5)
```
Output corresponding to it is:
```
4
100000
```
The best part in python function is that it helps in modular power also (which is faster than finding power and then mod).In pow (n,m,l) It produces : (n^m)%l as the output.
[Answer]
## PHP
```
function p($x,$n){return($n>1)?p($x*$x,$n-1):$x}
```
] |
[Question]
[
The challenge is to create an iterator(/generator) which iterates (in any order so as to reach all of them... ie no set should occur at infinity) over all possible non-empty finite sets(/tuples/lists) of positive integers (hence demonstrating their countability).
Since the problem of verifying the correctness of a solution is undecidable in some cases, an accompanying explanation of how your program works and what order the sets are returned in would be helpful
Each finite set should occur exactly once. So if left running long enough, the iterator should eventually hit each of {1}, {3,5}, {17,29,306} etc. exactly once
[Answer]
### GolfScript, 21 characters
```
;]]0{)\{.2$+.p}%\1}do
```
A GolfScript version which prints all generated sets. It basically does the same as my [Python version](https://codegolf.stackexchange.com/a/6395/1490) although not by recursion but instead collecting all possible sets in an array.
```
; // clear the stack
]] // put [[]] on the stack - the array of generated sets
(initially an array with only the empty set)
0 // counter starts with zero
{ // start of infinite loop
) // increase counter
\{ // map for each item of the array
. // duplicate item (i.e. this is a set)
2$+ // append counter
.p // print the newly generated set
}%\ // end of map => now the array contains all sets with max. up to counter
1} do // end of infinite loop
```
[Answer]
Why mess with iterators and suchlike if we can just return an infinite (lazy) list?
## Haskell, 40
```
s(α:η)=[α]:(s η>>=(\κ->[κ,α:κ]))
c=s[1..]
```
Works thusly:
```
s(α:η) --the nonempty subsets of the list beginning with α, followed by η
=[α] -- are: the singleton set [α]
:(s η -- and all nonempty subsets of η,
>>=(\κ->[ κ -- once on their own
, α:κ ] -- and once with α prepended to each of them.
))
c=s[1..] --c is the list of all nonempty subsets of the naturals.
```
Demonstration:
```
Prelude> take 16 c
[[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3],[4],[1,4],[2,4],[1,2,4],[3,4],[1,3,4],[2,3,4],[1,2,3,4],[5]]
```
[Answer]
### Python
*Note:* I wrote this version before the challenge became [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). I'll leave it here until I have a new one.
```
def allsets():
def setswithmax(n):
yield [n]
for m in range(1,n):
for s in setswithmax(m):
yield s+[n]
n = 1
while n:
for s in setswithmax(n):
yield s
n = n+1
```
It enumerates the sets with increasing maximum element, i.e. first of all it will generate all sets where max element is `1`, then `2`, ...
It does so by calling the generator `setswithmax` for increasing argument, which recursively builds these sets, i.e. a set with maximum `n` is obtained by iterating all sets with arbitrary max `<n` and then appending `n` to these sets.
You can see it in action on [ideone](http://ideone.com/k3p32).
[Answer]
### Scala 265:
```
object C extends Iterator[Set[Int]]{
var c=1
var M=1
var s=(1 to M)
var i:Iterator[Seq[Int]]=_
def n{i=s.combinations(c)}
def hasNext=true
n
def next:Set[Int]={
if(!i.hasNext)
if(c<M){
c+=1
n}else{c=1
M+=1
s=(1 to M)
n}
val r=i.next
if(r.max<M)next else r.toSet
}
}
```
Iterator is a well defined type in Scala, which means you have to declare what it returns (Set[Int]) in our case) and implement a method next and hasNext. For infinite Sets, hasNext trivially just returns true.
Here is code for testing:
```
object Cg6394IteratorTest extends App {
val ci = C
println (ci.take (1000).mkString ("\n"))
}
```
output:
```
Set(1)
Set(2)
Set(1, 2)
Set(3)
Set(1, 3)
Set(2, 3)
Set(1, 2, 3)
Set(4)
Set(1, 4)
Set(2, 4)
Set(3, 4)
Set(1, 2, 4)
Set(1, 3, 4)
Set(2, 3, 4)
Set(1, 2, 3, 4)
```
ungolfed:
```
object Cg6394Iterator extends Iterator [Set[Int]] {
var curLength = 1
var MAX = 1
var source = (1 to MAX)
var iter: Iterator [Seq[Int]] = _
def init { iter = source.combinations (curLength)}
def hasNext: Boolean = true
init
def next : Set[Int] = {
if (! iter.hasNext)
if (curLength < MAX) {
curLength += 1
init
} else {
curLength = 1
MAX = MAX + 1
source = (1 to MAX)
init
}
val coll = iter.next ()
if (coll.max < MAX) next else coll.toSet
}
}
```
[Answer]
### Python, 88
Simple implementation, like mentioned, counter and checking for bits in binary representation.
```
def P():
i=1
while 1:yield [n+1 for n,x in enumerate(bin(i)[2:][::-1])if x=='1'];i+=1
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
âe¢-ï♂~
```
The link below adds a footer to output the generated sets
[Run and debug online!](https://staxlang.xyz/#p=81767443226cad4261&i=&a=1)
## Explanation
Uses ASCII representation to explain:
```
zWiRSca-
z Empty set
W Loop forever
iR Range [1..current loop index]
S Powerset (*)
ca- Remove the powerset of [1..(current loop index-1)] from (*)
```
The footer is `mJ`, which outputs every generated set on a line, with the element separated by spaces.
] |
[Question]
[
well, I'm newly introduced to [befunge](http://en.wikipedia.org/wiki/Befunge).
it seems to be an amazing language but a bit hard to start with! anyway after about 2 hours of hard work I've created a code which could read a line from stdin and write same line into stdout(I'm using line -1 as buffer in this code):
```
0> :~:a-#v_$$v vg-10:-1< >$>:#,_@
^+1p-10\< >0>\: #^_^
```
since I'm new to this language I wanted to know if there is a shorter code to do such a thing.
I'm currently using [Rc/funge-98 v2 interpreter](http://www.rcfunge98.com/v2.html). note that none-trailing whitespaces are counted in your code.
[Answer]
# Befunge-98, 4
`~,#@`
[Try it online!](http://befunge-98.tryitonline.net/#code=fiwjQA&input=cmFjZWNhcg)
It works because `~` acts like `r` when there is no more input (credit to [David Holderness](https://codegolf.stackexchange.com/users/62101/james-holderness) for finding [this](https://github.com/catseye/Funge-98/blob/master/doc/funge98.markdown#standard-inputoutput) in the funge-98 spec)
[Answer]
## Befunge, 10
```
~:,a`!#@_
```
You were thinking a bit too hard about it I think :)
[Answer]
since it seems no one could create 7 character program, here is what I did. it works at least with befunge!
## Befunge, 7
```
~:,a`j@
```
] |
[Question]
[
This is a code golf problem: Say you have two files, one file s and one file h. The problem is that for each line l of s you should produce a list that contains all lines of h that contain l. By "contain" I mean a substring, so, for example the line "foobar12baz" contains either foo, bar, foobar, 12, 1 or baz, etc...
You may use any programming language or any program to accomplish this in the least number of characters possible. Instead of a list you may print an array, or other sequence type structure.
Here is some Haskell I wrote that does it in 103 characters, and assumes you have the following modules imported
Data.List
Control.Monad
Control.Applicative
```
let f = (<$>) lines . readFile in (\(a,b)-> [[d|d<-b, isInfixOf c d]|c<-a]) <$> liftM2 (,) (f "s") (f "h")
```
Example files:
"h"
```
asdf1
asd2asdf
s3adsf
```
"s"
```
1
2
3
```
Output:
```
[["asdf1"],["asd2asdf"],["s3adsf"]]
```
[Answer]
just grep is enough...
```
grep -Ff s h
```
[Answer]
Better:
```
puts IO.readlines('h').grep /#{IO.readlines's'}/
```
In ruby, 53 characters, outputs an array and not a file:
```
p IO.readlines('h').each{|m|m=~/#{IO.readlines's'}/}
```
This reads file 'h' for every line of 's' to save a variable. Not ideal.
Happy golfing!
[Answer]
```
while read -r;do grep "$REPLY" --h>"$REPLY";done<s
```
YEAAAAAAAH!!1
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/238199/edit).
Closed 2 years ago.
[Improve this question](/posts/238199/edit)
The event scheduler is a recurrent theme in event-driven architectures: something triggers an event that needs to be checked in the future one or more times. I has particular use in trading where you want to correlate one market event with price movements in the future at several time deltas (1ms, 100ms, 1s, 1 min, etc). During strategy discovery and backtesting the scheduling can reach billions of events.
A parenthesis here: this is a general algorithm challenge that can be implemented in any language. We provide an example implementation in C++ but it does not need to be written in that language necessarily.
The scheduler problem can be summarized in the following interface:
```
using Time = std::uint64_t; ///! nanos since epoch
/** Base class for all events to be handled by the scheduler */
struct Event {
virtual void fire( Time scheduled, Time now ) = 0;
};
/** A class that functions as a container for events to be fired in the future.
The same event can be added multiple times into the scheduler.
Distinct events can be added at the same time.
*/
class Scheduler {
public:
virtual ~Scheduler() = default;
/** Schedules one event */
virtual void schedule( Event* ev, Time tm ) =0;
/** Checks events and fires accordingly.
"t" is guaranteed ascending */
virtual bool check( Time t ) =0;
};
```
As a note, we decided to use raw points so not to introduce noise around smart pointers, move semantics, etc. These can be added later on.
The scheduler can be trivially coded using the standard containers but it will lead to log(N) algorithms for scheduling. Other trivial solutions will lead to O(1) for scheduling but O(logN) for checking. For example:
```
class StandardScheduler : public Scheduler {
public:
StandardScheduler();
virtual void schedule( Event* ev, Time tm ) override;
virtual bool check( Time t ) override;
private:
using EventMap = std::multimap<Time,Event*>;
EventMap events;
Time current;
};
```
Our goal in this test is to generate a solution that remains fast even for very large number of events, say 1E8. Therefore it helps if the solution is constant time O(1) in both scheduling and checking, in average.
The main requirements are:
1. Both scheduling and checking need to be very fast for extremely large number of events (eg 1E8). It is acceptable if it is slower at times (hiccups) for rebalance for example.
2. Individual events can be submitted multiple times
3. Distinct events can be submitted under the same time (same key in a map)
4. Events need to be fired in strict order by time.
The best solution will display the best execution times to schedule and iterate over a very large number of samples, which we set arbitrarily at 100,000,000 events with 3 random reposts of the same event. If two solutions come in first with 10% between them, I would like to consider the code that is smaller in size.
As per suggestion in the sandbox, I would like to propose winners per language: C++, Java, Python, etc since the commenter highlighted that this task is bread and butter for C/C++. So other languages can also compete.
The times need to be randomized and distributed over a span of time between 0 and 10 times the number of samples. The iteration is done every 5 time units.
A basic implementation for this challenge is provided on Github: <https://github.com/HFTrader/scheduler.git>.
The sample code is all standard C++ with no platform-specific features and is provided with a CMakeLists.txt which should make it able to compile in all major platforms, although it has only been tested on Linux.
If you choose to do it C++, you might clone, subclass the Scheduler class and replace it in main(). An example StandardScheduler is provided. In other languages, please replace with equivalent constructs.
```
git clone https://github.com/HFTrader/scheduler.git
cd scheduler
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=release ..
make
./scheduler 10000000 3
```
The timings in this C++ code provide the number of nanoseconds for scheduling and checking (iteration through time). A sample run can be like:
```
$ ./scheduler
Usage:
./scheduler <numsamples> <numreposts>
$ ./scheduler 10000000 3
Timings schedule:1196 check:126
Success!
```
The above code ran in 1196 and 126 nanoseconds per event, which is the key result. The above was ran in an AMD Ryzen Threadripper 3960X with 64Gb RAM under Ubuntu 20.04LTS and compiled with g++ 9.3 under "-O3".
If you are able to submit your solution to that Github repository, I will make sure to run all the solutions and post results.
[Answer]
## Proof that this challenge is impossible without extra assumptions
I'm assuming here that we can't take advantage of the fact that the range of a `Time` is limited, thus technically O(1). (If you do take advantage of that fact, you can solve the challenge in O(1) by using a separate array for every possible `Time` value – `schedule` is easy to implement with this technique, and `check` can work by iterating over every `Time` value less than the value being checked, which is very slow but technically O(1).)
If we can't exploit the limited range of `Time`, then any solution to this problem that obeyed the [restricted-complexity](/questions/tagged/restricted-complexity "show questions tagged 'restricted-complexity'") rules would give an O(*n*) comparison sort routine; simply use your program to schedule a large number of events, then check them all. Because sorting and checking are required to be O(1) on average, the combination of sorting and checking is thus required to be O(*n*) to handle all *n* events – so it can sort data in O(*n*). It's mathematically impossible to use a comparison sort for this, as comparison sorts can't go any faster than O(*n* log *n*); and any attempt to use a non-comparison sort would need to exploit the limited range of a `Time`.
A practically useful answer to this sort of problem would probably work via placing restrictions on the times at which `check` could be called (e.g. by requiring that it's called sufficiently often that performance-per-event that's O(log *t*) in the `Time` since the previous check is acceptable because *t* will be small), or via allowing events found during a single call to `check` to be fired out of order, but both of these techniques are currently disallowed by the question.
] |
[Question]
[
This puzzle is based on [this Math.SE post](https://math.stackexchange.com/q/3261079/3392). A more complex version of this problem can be found [over here](https://codegolf.stackexchange.com/q/189531/73483).
Assume I have some number of black shirts and some number of white shirts, both at least 1. Both colors of shirt have a non-zero durability. All shirts of a given color start with the same durability.
Every day, I pick out a clean shirt to wear, and it becomes dirty. Once I run out of all clean black shirts or all clean white shirts, I wash all my dirty shirts of both colors and start over. Clean shirts do not get washed. Whenever a shirt gets washed, its durability goes down by one. Immediately after washing, if the durability of a shirt reaches 0, it must be thrown out.
When picking which shirt to wear of a particular color, I always choose a shirt with the highest durability of that color to ensure even wear and tear among shirts.
# Challenge:
Take in a sequence of two characters of infinite length (eg. b b b w b w w b...) representing my choice of shirt to wear on that day. Continue execution until either my last black shirt or my last white shirt is thrown out. Once this occurs, stop consuming input and halt execution immediately. Note that the program must not consume any more input than is required before halting.
## Inputs:
Number of black shirts, number of white shirts, durability of black shirts, durability of white shirts, and an infinite number of two single characters, your choice (eg. b and w)
Note: if your language of choice does not *support* reading input of an infinite length (i.e. from a stream), assume an input of arbitrary length that is at least long enough for one color of shirt to run out.
## Output:
None. The program must simply immediately halt when the last shirt of either color is thrown away.
Note: if your language does not support reading input of infinite length, then instead you should output the number of characters processed.
## Test cases:
The following test cases represent the amount of input the program should process before halting. The sequence of w’s and b’s is infinite. The parenthetical afterwards is not part of the input or output, but simply represents the end state of how many shirts of each color have not been thrown out.
```
1 1 1 1 b
(0 b, 1 w left)
1 999 1 999 b
(0 b, 999 w left)
1 999 1 999 w w w w w w w w b
(0 b, 999 w left)
2 999 1 999 b w w w b
(0 b, 999 w left)
2 999 2 999 b w w w b w b w w w b
(0 b, 999 w left)
5 6 3 1 w w w w w b b b b b b b b b b b b b b w
(5 b, 0 w left)
```
# General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
* Default input rules apply for the first four arguments. For the arbitrarily long input sequence after the first four arguments, input must come from a source which can provide input one character or byte at a time, of theoretically infinite length, such as STDIN or some other stream. If your language of choice does not support these features, see above.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 14 bytes
```
*Š*‚[ICÓ-W_iõq
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f6@gCrUcNs6I9bZ0PT9YNj888vLXw/39LS0suEDYCwgKucjAsgGIIGw4B "05AB1E – Try It Online")
Uses `p` instead of `b`, because pink is prettier than black.
Explanation:
```
* # number of white shirts * durability of white shirts
Š # swap
* # number of pink shirts * durability of pink shirts
‚ # pair the two products in a list
[ # infinite loop
I # get the next input
= # print (only in the TIO version, not actually needed)
C # convert from binary (this yields 51 for p and 58 for w, don't ask why)
Ó # list of exponents in the prime factorization
- # subtract from the durability list
W_i # if the minimum of the list is now 0
õq # exit without printing anything
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~28~~ 22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
*U*V[XY*_iõq}©XαUY®≠-V
```
Inputs are separated by newlines in the order `amountOfWhiteShirts, whiteDurability, amountOfBlackShirts, blackDurability, shirtDigits...`, where white shirts are `1` and black shirts are `0`.
-3 bytes thanks to *@Grimy* by bringing to my attention that an input of `1`/`0` instead of `"w"`/`"b"` is allowed for the shirts.
[Try it online](https://tio.run/##yy9OTMpM/f9fK1QrLDoiUis@8/DWwtpDKyPObQyNPLTuUecC3bD//w25jLgMuYyB2AAIDWEQAA) or [try it online with additional `=` to print shirts without popping to verify it works as intended](https://tio.run/##yy9OTMpM/f9fK1QrLDoiUis@8/DWwlrbQysjzm0MjTy07lHnAt2w//8NuYy4DLmMgdgACA1hEAA).
**Explanation:**
```
* # Multiply the first two (implicit) input-integers
U # Pop and store it in variable `X`
* # Multiply the next two (implicit) input-integers
V # Pop and store it in variable `Y`
[ # Start an infinite loop:
XY*_i } # If either `X` or `Y` is 0:
õ # Push an empty string, since we don't want any (implicit) output
q # And stop the program
© # Store the next (implicit) input in variable `®` (without popping)
Xα # Get it's absolute difference with `X` (basically `X-input`)
U # Pop and store it as new value for `X`
®≠ # Push `®` falsified (1→0; 0→1)
Y - # Then subtract it from `Y`: `Y-falsified(®)`
V # And also pop and store it as new value for `Y`
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 22 bytes
```
Ｆ²⊞υ×ＮＮＷ∧⌊υＳ§≔υ℅ι⊖§υ℅ι
```
[Try it online!](https://tio.run/##fc29CsIwFAXgPU@R8QbqoKKLU8Glgz@gL5Am1/ZCciv5sb59bAcFQeRMBz7OMb0OZtCulNsQJKyUPOfYQ67klTxGaPie0zH7FgOoSn5VpXZi7MmhhJotHIjJZw/57S4pEHeTk3WM1HGdGrb4nMdPwRJrBzTZPZqAHjmhhZ9kPiplI7ZiLZZi/KT9k7EsHu4F "Charcoal – Try It Online") Link is to verbose version of code. Requires both black shirt values, then both white shirt values, then a stream of `b` and `w` characters on separate lines, otherwise behaviour is undefined. On TIO if you don't provide enough shirts you can see Charcoal attempt to prompt for input; if you ran locally then you would be able to continue enter `b` and `w` characters until you ran out of shirts at which point the program would exit. Explanation:
```
Ｆ²⊞υ×ＮＮ
```
Calculate the lifetimes of each colour of shirt.
```
Ｗ∧⌊υＳ
```
Repeat until one colour is exhausted.
```
§≔υ℅ι⊖§υ℅ι
```
Reduce the lifetime of a shirt according to the worn colour.
[Answer]
## C(tcc), ~~117~~ ~~116~~ 90 bytes
Uses 0x01 instead of b, and 0x02 instead of w.
```
main(a,b,c,d){scanf("%d%d%d%d",&a,&b,&c,&d);a*=c;for(b*=d;a*b;~c?b-=!c:a--)c=getchar()-2;}
```
[Try it online!](https://tio.run/##JcdNCoMwEAZQ6klUMCQys7DdNQTPMvPFv4UWrDvRq0dB3uqBNyClWabFCimBotv/kKW3ZRUfJRkho2RAJjovdYDvf6vVOsR76k@0GrjAV5gdwtBtGGW1jt/@SKnJP3lzy14X)
[Answer]
# [C# .NET](https://visualstudio.microsoft.com/), 260 bytes
```
class P{static void Main(string[]a){int b=int.Parse(a[0]);int g=int.Parse(a[1]);int q=g;int r=int.Parse(a[2]);int t=int.Parse(a[3]);int w=t;while(true){if(System.Console.ReadKey().KeyChar<104)q--;else w--;if(q<1){q=g;b--;}if(w<1){w=t;r--;}if(r<1|b<1)return;}}}
```
No TIO :(
Not the shortest but does the job great!
**EDIT: NOTE:** uses no spaces in input and (g)reen and (r)ed instead of (b)lack and (w)hite
[Answer]
# [Perl 5](https://www.perl.org/), 205 bytes
```
sub f{@s=map[$_>$_[0]?'w':'b',$_>$_[0]?$_[3]:$_[2],1],1..$_[0]+$_[1];while(join('',map$$\_[0],@s)=~/bw|wb/){$c=&{$\_[4]};(@w=grep$$\_[2]&&$$\_[0]eq$c,@s)[0][2]=0;@s=grep$$\_[2]||++$$\_[2]&&--$$_[1],@s if@w<2}@s}
```
[Try it online!](https://tio.run/##3VZLc9owED7Xv2JLXWwPJgGaZCY4Is5MD7n01NxSxmODDG6MTSxRDeOofz1dSZCQVzvtIYXIjCxLu5K@/fbBnFb54e0tWySQ1iEjs3h@aUcDO7rsDE8d4fSdxPHvJrD/NOxj3xv6Xfzt7en5FvbdYSCmWU7d72VWuI7j4062XvVD5pGf@4m4Ecm@V9sj0qxx4WAoAzcUZFJRLdgbNptGgV7bI6WEQ5wlnQDvdS91c9NqreXbbVsfjdKQpaE46cmQydsFo3BBGe/3v5QVBY5DRgZHgaVhdqCGf20fWDyjEDNIXQ@SBYdFMSnzlI4tgNnStUflouCJb97Ct8eLKtE9jieUR7wcx0sWjcq8rDwSRoHWg5BNs4oTF1y0Wl3jMhkow6MiGZhNRjmNCzLoSqmsbs7xfOvh9TbVxYa6eE5deOCp8zdoazR8VlbcNdypjaRv7uYZCpG/JybR@sB4lueQlHwKGh2DnKYc/kvTVkGzIs4cCDSfmD7QYu/g2dcHI2lgwFa0NaBQIBwVCqDpUZxKaDZhTRbQaw3aX3lUsMESjas4UUSpBbZFoGx9IwTmKt@rbTup0WXlCbquHeuhDIVKBsET15tnoysDCESGnjcrGQfUiJMsz/jSuGCKLGpKXw2UbSCtCMIE9lcpZoyqS8gK4FMK9ActsmKyDUxharn3OtIN1Idip92WyiXf3y@ucgamZPRYgqLofjGbqm/EhBkZv6As8iV2mJ6nGUPmqlfGqUGtEu@qumg4g47/OHheYoqXDHFgFRB4ezVgWxBT0lrDsqRlcvvJ57OLs4FXryLut2UqxPThETbH@AnuInTGJsQpr5z7GcyoBKtprcRP8bSUu1qzPy5rI87o9YIWIwpVrG3jBFiSpLzbIlTBSdI/1kwPvQcjOO24ngmujd2xzhclBzqb86Wj3Q3vcHfCR32CmxCkVGDnBaquqcm6oqnKlc752ddz53SdPvvm/4dstXx9O7NTxlx1pq8M4JmpeZUVHBqu2SyRkPhgxkKC0GnH@1Y0AmQgipTxowjeULO6YJ7kbYE6Pj4G0ydvEZR49OwqSKv3gKndBvMIVO8RKLHTAK1DOIIDZGrT6V5@xE6Auv0F "Perl 5 – Try It Online")
I assumed that picking the least worn out shirt each day doesn't actually influence the result. Any clean shirt of the chosen color will do. I also think that 2 shirts of durability 5 is the same as 1 shirt of durability 10, so we can simplify this to have just two shirts, one black and one white, but that affects the printed `(x b, y w left)` result so I didn't go that direction.
Ungolfed:
```
sub f0 { #as f() but ungolfed
my($countb,$countw,$durb,$durw,$get_todays_color)=@_; #inputs
my @s=( (map{{col=>'b',dur=>$durb,clean=>1}}1..$countb), #init @shirts
(map{{col=>'w',dur=>$durw,clean=>1}}1..$countw) );
while(join("",sort(map$$\_{col},@s))=~/bw/){ #while still both colors available
my $col = &$get\_todays\_color; #todays color
my @w = grep $$\_{clean} && $$\_{col} eq $col, @s; #wearable shirts
my $s = (sort{$$b{dur}<=>$$a{dur}}@w)[0]; #pick shirt with most durability left for today
$$s{clean}=0; #dirty in the evening
map{$$\_{clean}=1;$$\_{dur}--}grep!$$\_{clean},@s if @w==1; #wash if there was only one this morning
@s=grep$$_{dur}>0,@s; #toss out worn outs
}
@s #return not worn out
}
```
[Answer]
# [Python 2](https://docs.python.org/2/), 54 bytes
```
b,w,B,W=input()
l=[B*b,W*w]
while all(l):l[input()]-=1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P0mnXMdJJ9w2M6@gtERDkyvHNtpJK0knXKs8lqs8IzMnVSExJ0cjR9MqJxqqJFbX1vD/fw1THQUzHQUTHQVDTS5DODTAAw0B "Python 2 – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Work out change [closed]](/questions/647/work-out-change)
(6 answers)
Closed 6 years ago.
## Overview
In the US, the common denominations are the penny ($0.01), the nickel ($0.05), the dime ($0.10), the quarter ($0.25), one dollar, two dollars (less common but lets pretend it's common), five dollars, ten dollars, twenty dollars, fifty dollars, and one hundred dollars. ($1 to $100 respectively).
Your goal is to take an arbitrary money value and output a list of the fewest bills and coins that add up to that amount.
## Rules
* The output must be minimal. You cannot output "4175 pennies" for $41.75.
* The inputs and outputs can be any format or type, as long as you can explain what it means.
* Values must be kept the same. For instance, your program cannot accept "6523" for $65.23. It must accept the decimal value "65.23"
## Examples
If the input is $185.24, the output should be something like
$100 + $50 + $20 + $10 + $5 + $0.10 + $0.10 + $0.01 + $0.01 + $0.01 + $0.01
For the input $44.75, another acceptable output would be
[0, 0, 2, 0, 0, 2, 0, 3, 0, 0, 0]
Meaning 2 $20s, 2 $2s, 3 quarters, and 0 of the other denominations.
## Bonus
Accept another argument for the list of denominations so your program will work in other countries.
For example, if it's given this list of denominations.
[15, 7, 2.5, 1, 0.88, 0.2, 0.01]
and the money value "37.6", it should return something like
15 + 15 + 7 + 0.2 + 0.2 + 0.2
[Answer]
# Mathematica, 54 bytes
```
#~NumberDecompose~{100,50,20,10,5,2,1,.25,.1,.05,.01}&
```
input
>
> [44.75]
>
>
>
output
>
> {0, 0, 2, 0, 0, 2, 0, 3, 0, 0, 0.}
>
>
>
# Mathematica, 82 bytes --WITH BONUS--
```
(s=#~NumberDecompose~#2;Row@Flatten@Table[Table[#2[[i]]"+",s[[i]]],{i,Length@s}])&
```
**Input**
>
> [37.6, {15, 7, 2.5, 1, 0.88, 0.2, 0.01}]
>
>
>
**output**
>
> 15 +15 +7 +0.2 +0.2 +0.2 +
>
>
>
[Answer]
# [PHP](https://php.net/), 96 bytes
```
for(;$i<11;)$argn-=$c*$r[]=$argn/($c=[100,50,20,10,5,2,1,.25,.10,.05,.01][+$i++])^0;print_r($r);
```
[Try it online!](https://tio.run/##HYmxDoIwFAB3PoO8oZVHbQnEoTQOhsFFFzeChDQIXdrmhdm/dq6E6e5ycY2pvcY1ZjNRoJHmGGhzfmHfbnw8X/dbx3UGEy3e5HUtLk2u0ycQ0@BapTQ/VmnAnoD6wRx5ZmBNr6TERmIlUe2CFSoUVYNiLyF3SjX0BbiiGPhb6kjObyMxIK5T@vlQ2smu8x8 "PHP – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 73 bytes
```
x=input()+1e-5
for c in 100,50,20,10,5,2,1,.25,.1,.05,.01:print x//c;x%=c
```
[Try it online!](https://tio.run/##DcZBCoAgEADAe6/YS1C06a7gYQtfI0VeVMTAXm@eZvJXnxRN782FmN@6rBtfu53uVMBDiMBEaAkNIY@gQUZlLKoBDYiPXEKs0LT2Z5ud711Eifw "Python 2 – Try It Online")
A greedy strategy works for these values. Going through currencies largest to smallest, we remove the greatest whole number of the currency, leaving the modulo as the remainder. This repeated divmod is effectively mixed based conversion.
The `+1e-5` is to ward off floating point errors where `$0.09999999999999998` is left but that's less than 1 cent.
I thought about compressing the list of values but didn't think of a good approach. There's not a uniform pattern for the values.
[Answer]
# Javascript(ES6), 97 bytes with bonus
```
f=(m,d=[100,50,20,10,5,2,1,0.25,0.1,0.05,0.01])=>{for(i of d){z=Math.round(m/i);alert(z);m-=z*i}}
```
# Java, 209 bytes
*so verbose...*
```
interface A{static void main(String[]a){int m=Integer.valueOf(a[0]);for(double i:new Double[]{100.0,50.0,20.0,10.0,5.0,2.0,1.0,0.25,0.1,0.05,0.01}){int z = (int)Math.round(m/i);System.out.println(z);m-=z*i;}}}
```
Both use same algorithm as jacoblaw's.
[Answer]
# **Python 2**, ~~53~~ ~~94~~ ~~90~~ 78 bytes with bonus
```
def f(m,d=[100,50,20,10,5,2,1,.25,.1,.05,.01]):
for i in d:
print m//i
m%=i
```
\*The indentation is a space for line 2, and tabs for the other lines
The function takes in the amount of money and a *sorted* list of the denominations (if not US).
Examples:
```
>>> f(44.75)
0.0
0.0
2.0
0.0
0.0
2.0
0.0
3.0
0.0
0.0
0.0
>>> f(37.6, [15, 7, 2.5, 1, 0.88, 0.2, 0.01])
2.0
1.0
0.0
0.0
0.0
3.0
0.0
>>> f(8, [5,4,1])
1
0
3
```
] |
[Question]
[
* Copy and paste or `curl` this text:
<http://lorem-ipsum.me/api/text>
* Using any language make the text palindromic.
* You may remove letters.
* You may rearrange letters.
* The goal is to make the text palindromic by the **sequence of the letters and spaces**. The end result might not contain words. It will be merely a sequence of letters and spaces.
* Capital letters are considered the same as lowercase letters.
* You may use each letter only once, or you may remove the letter.
* You may also use each space only once. Or you may remove the space.
* The result should be the longest palindrome you can programmatically create from the text.
* While you could technically print just the letters `AaA` or something similar to it, that is not what I am looking for.
* Your palindrome creator should work with any text.
* A palindrome, by definition, is a word, phrase, number, or other sequence of symbols that reads the same backward as forward. A sequence of symbols that reads the same backward as forward is the acceptable palindromic definition I am looking for in this `CodeGolf` example.
* Scoring will be `Length of palindrome` / `Length of code`. The winner is the one with the highest score.
**Text**:
```
Lorem ipsum dolor sit amet, consectetur adipisicing elit, possimus voluptatem do ut vel deserunt laborum. cupidatat libero minim at a aute minus cupiditate excepturi reiciendis blanditiis, atque vero. dolorem dolores dolore corrupti aute recusandae repellat recusandae modi deleniti libero nostrud aute delectus quidem alias odio nostrum pariatur. placeat minus similique a aliquip facere ullamco officiis eligendi ad at magnam commodi maxime.
Adipisicing modi enim similique maxime ex nisi sed eu suscipit earum corrupti assumenda perferendis cumque maiores qui praesentium nobis. Sed voluptas consequatur voluptates rerum facilis qui dolor commodi minim provident, magnam facere, tenetur. Aliqua voluptatibus delectus illum dolorem excepturi aliquip duis odio. Excepturi similique hic iusto eu consectetur laboriosam quidem esse eiusmod, anim. Eu consequatur magnam tempor vel.
Nobis incididunt eius cum distinctio magnam velit facilis libero ullam, tenetur distinctio eius eveniet. Anim possimus expedita fugiat facilis vel consequatur in temporibus laboriosam at molestiae velit cupidatat. Vel consequatur voluptate cum sint dolores ullamco quas omnis quibusdam id officiis tenetur voluptas, tempore tenetur aliquam debitis. Nostrud, do in numquam magnam quia voluptate incidunt accusamus distinctio officia molestiae fuga. Nam corporis ex quos recusandae sed.
Ullamco incidunt cupidatat eos voluptate delectus nostrud nisi irure quod quis alias. Fuga quam autem mollit ex dolores quod non tempor mollitia quas labore sapiente a anim deserunt expedita minus. Ex pariatur accusamus alias deleniti quo, quia similique voluptas. In voluptatibus esse perferendis commodo aute repellendus accusamus laboriosam deserunt aute possimus laboriosam.
Labore hic tempora, ad iusto hic aliqua ducimus. Distinctio omnis tempore incididunt ut sed mollit, quidem, aute sunt eius eveniet, vel distinctio cupiditate eius atque. Fuga asperiores tenetur enim, provident similique aliqua nostrum ad dolorum, molestiae, repudiandae ad sunt. Consequatur ullamco a nisi aliqua non omnis officia.
Labore sapiente obcaecati libero quas eos incididunt. Saepe quas voluptas mollitia consectetur dolores dolores officiis id, quo, laboriosam reprehenderit alias. Voluptates cumque dignissimos, cumque dolor. Incididunt minima consectetur harum et.
```
[Answer]
# Mathematica ~~146~~ 92 chars (score 2130/92 = 23.15)
## Shorter Version (92 chars)
This palindrome has the characters grouped,
```
""<>{s=({#[[1]],Length@#~Quotient~2}&/@ Gather@Characters@t)
/.{c_,n_}:>c~Table~{n},Reverse@s}
```
---
## Longer Version (146 chars)
This will return a maximum length, randomized palindrome from t.
Because capital letters are equivalent to lowercase letters, I converted all capitals to lower case. (This can be changed if necessary.)
```
f@t_ := "" <> Join[s = RandomSample[ Flatten[({#[[1]], Quotient[Length[#], 2]} & /@
Gather[Characters@ToLowerCase@t]) /. {c_, n_} :> ConstantArray[c, n]]], Reverse@s]
```
**Example**:
When `t` is the suggested, Lorem ipsum, text. (Ignore line returns; all line returns were generated via the SE editor.)
>
> "ti,iopexri rpiuu opaat tismimetnesa lvuot oiaiu oaaittcoar nc
> muapua elhpibemu utin ia f ihide sdourgeeic e oaasa.marsae dstircd
> ci ndn rs t egoaiq.aeatntreusng xi a lumalnoiieqqeq cc otiueasniieu
> nrpupdlmnai o cdsm t gt.iccmittli i t tu.rust.li maui bea gqiceeo
> pncu eonttecvtutqun eaaariusoquppsedlqu scrddmt esiafidurs hitlpna
> nlamltire ivmumbabi nbuderup td x uuualsoq.eiib li olel ru aeelau
>
> idbc lrop iil ssur anda o scnmsr ,m uri,teo
> esmiaveuomrt ldqqaid ihi snsr spueeoevcre oe
> msirulaleaisormm.oicolarsstteo td aatncn ieqrsuam boid te utcf eccp
> siacu m etnqutlacniiereltiulqemltaqx a
> qtdlxmliibileoheesimittlusqemooamuiippeaiilcgudsatfsiemamsc irn
> rsgoi, ie
> nmteiaiiptraned alsomsui noru ic,mditi ic ouud oadmv iudinrfuludet
> eeiidueel nndaemcrepnioe sials unetuamconn,i
> ubpo eiu ei dsn equi,ue ostmp udiatqu dalmau nueeiit ln e mioancteop
> ntiiao ts noeefubtefrit ldeop earnmsm oas
>
> d.catirotulvliodiellmesurotiomsmduia.nauenb iuiroimduriohs.lrndsaroc
> t inidrssq apeuionnlaa eqdroounosmotidr arxr o taouarut ussce uamae
> is.dcadaimuoaprad iifl i lmml i lfii darpaoumiadacd.si eamau
> ecssu turauoat o rxra rditomsonuoordqe aalnnoiuepa qssrdini t
> corasdnrl.shoirudmioriui bneuan.aiudmsmoitorusemlleidoilvlutoritac.d
>
> sao msmnrae poedl tirfetbufeeon st oaiitn poetcnaoim e nl tiieeun
> uamlad uqtaidu pmtso eu,iuqe nsd ie uie opbu
> i,nnocmautenu slais eoinpercmeadnn leeudiiee tedulufrnidui vmdao duuo
> ci itidm,ci uron iusmosla denartpiiaietmn
> ei ,iogsr nri
> csmameisftasdugcliiaeppiiumaoomeqsulttimiseehoelibiilmxldtq a
> xqatlmeqluitlereiincaltuqnte m ucais pcce fctu et diob mausrqei
> ncntaa dt oettssralocio.mmrosiaelalurism eo ercveoeeups rsns ihi
> diaqqdl trmouevaimse
> oet,iru m, rsmncs o adna russ lii porl cbdi ualeea ur lelo il
> biie.qoslauuu x dt puredubn ibabmumvi eritlmaln anpltih srudifaise
> tmddrcs uqldesppuqosuiraaae nuqtutvcettnoe ucnp oeeciqg aeb iuam
> il.tsur.ut t i ilttimcci.tg t msdc o ianmldpuprn ueiinsaeuito cc
> qeqqeiionlamul a ix gnsuertntaea.qiaoge t sr ndn ic dcritsd
> easram.asaao e cieegruods edihi f ai nitu umebiphle aupaum cn
> raocttiaao uiaio touvl asentemimsit taapo uuipr irxepoi,it"
>
>
>
[Answer]
## Python, 1/4
A single character is a palindrome, so...
```
s[0]
```
presuming the target text is stored in `s`.
[Answer]
## Ruby, 78 chars
Reads from standard input.
```
s=gets.downcase.chars.group_by{|c|c}.map{|k,v|k*(v.size/2)}*''
$><<s+s.reverse
```
For example, passing the text from @LegoStormtrooper's first comment on the question:
```
What if the text isn't symmetric? For example, the text of this comment in this question can't be palindromed as it has more than one letter that occurs an odd number of times, hence it can be flipped without duplicating a letter.
```
The program will return this:
```
whhhhhaaaaaattttttttttttt iiiiiiiffeeeeeeeeeeexssssnnnnnn'mmmmrrrrccccooooopplll,uubddddddbuu,lllppoooooccccrrrrmmmm'nnnnnnssssxeeeeeeeeeeeffiiiiiii tttttttttttttaaaaaahhhhhw
```
If you don't want the punctuation at all (on re-reading the question it sounds like you only want letters and spaces) this will work (87 chars):
```
s=gets.downcase.scan(/[a-z ]/).group_by{|c|c}.map{|k,v|k*(v.size/2)}*''
$><<s+s.reverse
```
Which returns:
```
whhhhhaaaaaattttttttttttt iiiiiiiffeeeeeeeeeeexssssnnnnnnmmmmrrrrccccoooooppllluubddddddbuulllppoooooccccrrrrmmmmnnnnnnssssxeeeeeeeeeeeffiiiiiii tttttttttttttaaaaaahhhhhw
```
[Answer]
## Python 2.7 - 82
Takes an input, converts it all to lower case,
makes an array with half (rounded down) of each character,
then prints that out concatenated to itself in reverse.
Worst case scenario, it outputs an empty string if every character is unique.
```
L=raw_input().lower()
o=[x*(L.count(x)/2)for x in set(L)]
print''.join(o+o[::-1])
```
[Answer]
## Python, 107
```
s="""Lorem ipsum dolor sit amet, consectetur adipisicing elit, hic a sunt odio eius culpa labore. vero vero possimus irure quidem est saepe ut do quis excepturi incididunt. magna eveniet nisi enim quidem distinctio.
Ullam saepe officiis consequatur, provident soluta blanditiis sunt possimus minima impedit corporis voluptatibus occaecat distinctio mollitia, commodo et. Facilis autem cum dolor dignissimos magna modi nisi labore animi incididunt numquam quam voluptatem optio tempor provident fugiat ullam. Consequat tempora numquam minim tempore eius perferendis ullamco labore corporis officiis. Saepe deserunt a asperiores rerum quis excepteur odio voluptatibus ducimus itaque.
Qui nam provident corrupti sunt velit est laboris. Delectus tempora possimus quas cillum exercitation debitis cupidatat omnis voluptatibus. A dignissimos saepe repellat nostrum quaerat rerum molestias, alias dolorum provident fuga repellat sed, esse cum illum culpa animi. Placeat atque necessitatibus nostrud saepe maxime cupiditate, impedit elit iure hic.
Excepturi id numquam odio aliquam maiores, expedita eveniet. Repellendus eos voluptates quaerat excepteur sunt velit consectetur vel eius ad voluptatem corporis cillum tempore incidunt molestiae. Atque tempora, duis vero, tempore et sint nostrud molestiae laboris eligendi maxime nam reprehenderit.
Fugiat anim commodo sed incidunt, et aut, labore corrupti velit incididunt quaerat. Aliquam saepe minima sunt minima eos, nobis, eu delectus itaque optio consequatur voluptatibus delectus ex sapiente deserunt dolor. Optio doloribus officiis ducimus dolores.
Voluptas commodo cupidatat molestiae tempora quia consequatur. Repellendus ea rerum exercitationem, odio voluptatem ullam perferendis ea animi deleniti deleniti quaerat magnam repellat voluptates. Obcaecati aut exercitation dolore nisi eos."""
import itertools
t=''.join(''.join(list(g[1])[1::2]) for g in itertools.groupby(sorted(s)))
print t+t[::-1]
```
`itertools.groupby(sorted(s))` groups identical characters. `list(g[1])[1::2]` takes each group and cuts it in half, rounding down for odd-length groups. It then joins the lists together and prints the resulting string concatenated with its reverse. Could be improved in a number of ways, as already demonstrated by others.
] |
[Question]
[
The class [`System.Globalization.EastAsianLunisolarCalendar`](http://msdn.microsoft.com/en-us/library/System.Globalization.EastAsianLunisolarCalendar.aspx) of the `mscorlib.dll` assembly is non-nested `public` but its sole instance constructor is `internal` and it also declares some `internal abstract` members.
**The problem:** Write a C# class in your own assembly (code must compile with usual C# compiler) where a class derives from (inherits) the `System.Globalization.EastAsianLunisolarCalendar` of the BCL.
*Your class must have `System.Globalization.EastAsianLunisolarCalendar` as its* ***direct*** *base class.* It is not allowed to have a third class in "between" your class and that class in the inheritance hierarchy.
(Advanced stuff like dynamic assemblies or runtime IL emission is not needed.)
(Stated as a C# problem. Discussions on whether the equivalent problem can be solved in other object-oriented languages too, will also be considered interesting.)
It is not required that the class you write is usable in any way ;-)
[Answer]
Well, I have either to call a base constructor (which is not accessible) or an other constructor in the same class.
```
public abstract class Class1 : System.Globalization.EastAsianLunisolarCalendar {
private Class1() : this(1) {}
private Class1(int i) : this() {}
}
```
So let's call the constructors recursive. Not very useful, but who cares?
[Answer]
One way to do it is to inherit a [subclass of `System.Globalization.EastAsianLunisolarCalendar`](http://msdn.microsoft.com/en-us/library/system.globalization.eastasianlunisolarcalendar%28v=vs.110%29.aspx):
```
public class MySubclass : System.Globalization.JapaneseLunisolarCalendar
{
public static void Test()
{
var instance = new MySubclass();
Console.WriteLine(instance is System.Globalization.EastAsianLunisolarCalendar);
// this prints "True"
}
}
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/255988/edit).
Closed 1 year ago.
[Improve this question](/posts/255988/edit)
Given two non-zero 16-bit integers `a` and `b`, decide the smallest number of shift operations needed to turn `a` into `b`. A shift is one of the following (big-endian) operations:
* `shl` (shift left): move all bits to the left, adding a `0x0` bit to the right.
* `shr` (shift right): move all bytes to the right, adding a `0x0` bit to the left.
* `sar` (arithmetic shift right): move all bits to the right, duplicating the leftmost bit.
* `rol` (rotate left): move all bits to the left, replacing the rightmost bit with the leftmost bit.
* `ror` (rotate right): move all bits to the right, replacing the leftmost bit with the rightmost bit.
Or, if the number is expressed in 16-bit big-endian binary x15x14...x1x0, then allowed operations are listed as following:
```
(original) x15 x14 x13 x12 x11 x10 x9 x8 x7 x6 x5 x4 x3 x2 x1 x0
shl x14 x13 x12 x11 x10 x9 x8 x7 x6 x5 x4 x3 x2 x1 x0 0
shr 0 x15 x14 x13 x12 x11 x10 x9 x8 x7 x6 x5 x4 x3 x2 x1
sar x15 x15 x14 x13 x12 x11 x10 x9 x8 x7 x6 x5 x4 x3 x2 x1
rol x14 x13 x12 x11 x10 x9 x8 x7 x6 x5 x4 x3 x2 x1 x0 x15
ror x0 x15 x14 x13 x12 x11 x10 x9 x8 x7 x6 x5 x4 x3 x2 x1
```
Test cases:
```
1, 4 => 2 # shl, shl
10, 8 => 4 # shr, shr, shl, shl
1, 65535 => 16 # ror, sar*15
```
Shortest code wins.
[Answer]
# JavaScript (ES6), 107 bytes
*-5 thanks to [@l4m2](https://codegolf.stackexchange.com/users/76323/l4m2)*
Expects `(a)(b)`.
```
p=>g=q=>g[g[p]=q]?0:1+g(q,(_=>{for(v in g)[v*2,h=v/2,v<<15|h,v>>15|v*2,v&1<<15|h].map(v=>g[v&65535]=1)})())
```
[Try it online!](https://tio.run/##bc3BCoJAEAbge0/hSWZqM9faiHC3B5ElxHQ1zF015lI9u2kdFYYZ@PiZ/55S2mdd5Z7bxt7yoZCDk8rIdlyJSZyWrb6EZ74x0DK4SvUqbAfkVY1nMKF1xEpJu4hRHHPxLhkpNd7Jyed/08EjdUDTQ/KPQuyFlhw/CIhDZpve1nlQWwMFcBwHVzOMlvAwxxDhtBT9lY5tXw "JavaScript (Node.js) – Try It Online")
### Commented
```
p => // p = initial value
g = q => // q = target value
g[g[p] = q] // mark p as already found
? // if q was found:
0 // stop the recursion
: // else:
1 + // increment the final result
g( // do a recursive call:
q, // pass q
( _ => { // dummy function to process a for
for(v in g) [ // for each value v found so far:
v * 2, // compute shl
h = v / 2, // compute shr
v << 15 | h, // compute ror
v >> 15 | v * 2, // compute rol
v & 1 << 15 | h // compute sar
] //
.map(v => // and for each of them:
g[v & 65535] // keep the 16 lower bits
= 1 // and mark the result as found
) // end of map()
})() // end of for
) // end of recursive call
```
[Answer]
# [Python 3](https://docs.python.org/3/), 255 bytes
```
def f(x,y,i=0):
while 1:
for p in product(*[[lambda n:n[1:]+'0',lambda n:n[:-1],lambda n:n[0]+n[:-1],lambda n:n[1:]+n[0],lambda n:n[-1]+n[:-1]]]*i):
r=x
for q in p:r=int(q(bin(r)[2:].zfill(16)),2)
if r==y:return i
i+=1
from itertools import*
```
[Try it online!](https://tio.run/##ZY7BasMwEETv/oqFHiLZarGSOgSBvsTokMQWWZAlZauQuD/vSiEEQ0@783ZmmTinS/C7ZRlGC5Y9xCxQt1xVcL@gG0HmDWwgiIAeIoXhdk6s7nt3nE7DEbzyvVSm2bQbsULqU5q1bk3zH5ZcOa1ZtrycxtRYegCQfpRRWlyfLRRp9Ild2Qk9I95vlfn6tegck3vOxZYXO9oc1LOiMd3IA2aGjZaVpTABppFSCO4HcIqBUr1EKi8tkwK@Oa/eshVwyPoDVoZ91@06zpc/ "Python 3 – Try It Online")
Brute force method (very slow). It goes through every single possibility. The last test case times out on TIO.
Takes in two integers and returns an integer.
---
**Explanation:**
```
def f(x,y,i=0): # Create a function, f, which takes in x and y. Define i as 0
while 1: # Forever:
for p in product(*[...]*i): # Go through every combination of length i. (Five functions have been defined here, each corresponding to one of the shifts/rotations)
r=x # Set r to x
for q in p:r=int(q(bin(r)[2:].zfill(16)),2) # Apply each function in p to r
if r==y:return i # If r equals y, return i (the number of functions we applied)
i+=1 # Add one to i
from itertools import* # Import the itertools library
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 61 bytes
```
≔⟦Ｎ⟧θＮη≔Ｘ⁸¦⁵ζＷ¬№θη«≔ΣＥθ⟦⊗﹪κζ÷κ²⁺＆κζ÷κ²⁺⊗﹪κζ÷κζ⁺×﹪κ²ζ÷κ²⟧θ→»Ｉⅈ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=jZDPSsNAEIfx2DzF0tMspKAFIdhTbS8VUoJ6EEIO-bPtDm522-xuAhWfxEsPFX0mn8ZdGqWghx7nm29-ML-3z5LnTalysd-_W7MaRV8Xd1OtcS0hXciNNUtbF6wBmoVkSyfBKeNu7t1EdQ5EIbmmIdk53nEUjMBSGZgpKw1sQ8IppeQlGPQ3D7aGON_4TTpXthCsglhVVih49iEuaSHNHFusmCdjBxJhNdyi6VCzqayO4h_vRzwndfdrP2LN9Ik7pv-HZ_7CdzGIVcvg5h7X3LjxNUgadJ_Ocm3gCdyzk4MuSt0X-5EOR60YZoerSxId0Tc "Charcoal – Attempt This Online") Link is to verbose version of code. Explanation: Lots of brute force, so times out for anything interesting.
```
≔⟦Ｎ⟧θ
```
Start with having discovered `a`.
```
Ｎη
```
Input `b`.
```
≔Ｘ⁸¦⁵ζ
```
Precompute `32768`.
```
Ｗ¬№θη«
```
Repeat until `b` is discovered.
```
≔ΣＥθ⟦⊗﹪κζ÷κ²⁺＆κζ÷κ²⁺⊗﹪κζ÷κζ⁺×﹪κ²ζ÷κ²⟧θ
```
Replace each discovered value with the results of its five shifts.
```
→
```
Keep track of the number of shifts taken.
```
»Ｉⅈ
```
Output the required number of shifts.
106 bytes for a less inefficient version that also outputs the list of shifts required:
```
≔Ｘ⁸¦⁵ζ≔Ｅ⊗ζ⟦⟧η⊞υＮＮθＦυＦ¬§ηθＦ⁵«≔§⟦⊗﹪ιζ÷ι²⁺＆ιζ÷ι²⁺⊗﹪ιζ÷ιζ⁺×﹪ι²ζ÷ι²⟧λκＦ¬§ηꫧ≔ηκ⁺§ηι⟦§⪪”&→∧¡?kiNⅉ｜Ｍ”³λ⟧⊞υκ»»§ηθ
```
[Try it online!](https://tio.run/##jVFNawIxFDxvfkXw9AIpqEUQPG3x4kFZaG@yh9WNTTAmaz60bPG3bxO7KUvroZeENzN58@Zlzyuz15Xsutxa8a6g0FdmYE7xjFDckgXq8XXVwFL7nWQ1tIHaluHggS@85eApXqnGu40/7cJzEvBhfQ71QRsMnuD7vdEOcrdSNfsATvGZkJ6YEfyJst4zKbbJeK1rLzWIOBmJlm4pLqJmEZkGoJDewotwV2FZrupv4R9dEv6na/ujfhMnZgfaKXncvKRYBvgYImePsh5j1pCxDzlkeqcBJOKmU/3aSOFgZLm03NjKGC2NNiOKn0n0LOPWsyz9x32AG7qhwgj1e9uLrpuM0bx7usgv "Charcoal – Try It Online") Link is to verbose version of code. Requires `a` and `b` to be different. Explanation:
```
≔Ｘ⁸¦⁵ζ
```
Precompute 32768.
```
≔Ｅ⊗ζ⟦⟧η
```
Start with not having discovered anything.
```
⊞υＮ
```
Start a breadth-first search at `a`.
```
Ｎθ
```
Input `b`.
```
ＦυＦ¬§ηθ
```
Loop over the discovered numbers until `b` has been discovered.
```
Ｆ⁵«≔§⟦⊗﹪ιζ÷ι²⁺＆ιζ÷ι²⁺⊗﹪ιζ÷ιζ⁺×﹪ι²ζ÷ι²⟧λκ
```
Loop over the five shifts and compute the current shift's value.
```
Ｆ¬§ηκ«
```
If this value has not yet been discovered, then...
```
§≔ηκ⁺§ηι⟦§⪪”&→∧¡?kiNⅉ｜Ｍ”³λ⟧
```
... record the shifts needed to reach it, and...
```
⊞υκ
```
... add it to the list of discovered values.
```
»»§ηθ
```
Output the shifts needed to reach `b`.
] |
[Question]
[
This code golf challenge is to show directions through numbers.
When the user enters a number, then that means a direction change as follows:
```
0 means stay still
1 means forward (initially from left to right and initially start with `:`)
2 means turn right
3 means turn left
4 means go backward
```
I will show you an example: `122123333114`
`1` means 1 step forward
```
:═>
```
`2` means 1 step to the right
```
:═╗
‖
V
```
`2` means 1 step to the right
```
:═╗
‖
<═╝
```
`1` means 1 step forward
```
:═╗
‖
<══╝
```
`2` means 1 step to the right
```
^:═╗
‖ ‖
╚══╝
```
`3` means 1 step to the left
```
<═╗:═╗
‖ ‖
╚══╝
```
`3` means 1 step to the left
```
╔═╗:═╗
‖ ‖ ‖
V ╚══╝
```
`3` means 1 step to the left
```
╔═╗:═╗
‖ ‖ ‖
╚═>══╝
```
`3` means 1 step to the left
```
╔═^:═╗
‖ ‖ ‖
╚═╝══╝
```
`1` means 1 step forward
```
^
╔═‖:═╗
‖ ‖ ‖
╚═╝══╝
```
`1` means 1 step forward
```
^
‖
╔═‖:═╗
‖ ‖ ‖
╚═╝══╝
```
`4` means 1 step backward
```
‖
╔═V:═╗
‖ ‖ ‖
╚═╝══╝
```
**These are the rules:**
* Start with `:` and the initial direction will be from left to right
If starting with `0`, then start with:
```
:
```
If starting with `1`, then start with:
```
:=>
```
If starting with `2` then start with:
```
:╗
‖
V
```
If starting with `3`, then start with:
```
^
‖
:╝
```
If starting with `4`, then start with:
```
<=:
```
* Any other numbers or letters in the input will be ignored
`T6@1 92J;{4` will mean `124`
* If two arrows came on top of each other, the new arrow should overwrite the old one
An example of this:
```
╔═╗:═╗
‖ ‖ ‖
V ╚══╝
```
`3` means 1 step to the left
```
╔═╗:═╗
‖ ‖ ‖
╚═>══╝
```
* Arrow head should be `>` for left to right direction
* Arrow head should be `<` for right to left direction
* Arrow head should be `V` for top to bottom direction
* Arrow head should be `^` for bottom to top direction
Do not forget the joint if you turn.
```
:╗
‖
V
:
<═╝
^
‖
╚:
╔═>
:
```
I hope I did not miss anything.
If you have any questions or if I missed anything, I will be editing this post.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~302~~ ~~306~~ ~~322~~ 327 bytes
* +4 bytes to fix the edge case with the \$-i\$ direction (its angle is negative so we need to mod 4)
* +16 bytes for even more edge case fixes in the stepping algorithm...
* +5 bytes to fix the edge case where no inputs from 1-4 are present.
```
P=Math::PI/2
b=0i;f=d=p
c={b=>?:}
gsub(/[1-4]/){x=$&.to_i;d||=1
c[b+=d]="╗╝╚╔╗"[d.arg/P%4+x%2]if x[1]>0
d*=[0,1,1i,-1i,-1][x]
c[b+=d]="═║"[d.imag.abs]if x<4||!f
f=1}
c[b+=d]=">V<^"[d.arg/P]if d
q=c.keys.map &:rect
q=q.pop.zip *q
i,j=q[0].minmax
k,l=q[1].minmax
puts (k..l).map{|y|(i..j).map{|x|c[x+y*1i]||' '}*''}
```
[Try it online!](https://tio.run/##TY3NboJAEMfv@xTUVFHEhaWc0LHnHpp46mWzbfgQuyqyCCZLXd6hTUqaNOnL8SClaBrbSSaZ3@T/sT8EZdsu4N4vnj1vcWc5KACbT2OIQKAQjgHMb70KrfJDMLQombjMGh0lXA9wkT7xaaQUEBTSYAwRg15TfzT1V1N/NvV7d/dohP39ylr03bHsO4zHmqSEzW0UGUBtk5iEm5PzMirZ/5zXpn472Xnir7Af5GfvzFXqKkYxkOpPO3@YPV6KTrIIZRDizbLMceILbeDtl2HR/TIsUoFfuNCMDHFzDRm1GU74LvEl2pjbjsmFxaHIteEG4@3olHJUpRpyjNe/JFVI5bg0CGdK6ZpeGbpetS1xHOLcdEOI@52Kgqe7vJ3sfgA "Ruby – Try It Online")
### Explanation
We initiate the grid as a hash table where the keys are complex numbers (real is the X-axis, imaginary is the Y-axis, lower numbers are closer to the top-left corner). This is convenient because we can initialize the direction variable as \$1\$, multiply by \$i\$ to turn right, and multiply by \$-i\$ to turn left. Also, we can quickly determine which way we're facing by dividing the direction's angle by \$\pi/2\$ and use that in our lookup tables.
Our algorithm, then, is roughly as follows:
1. Get the next number from the input in the range 1-4.
2. If the number is 2-3, step once and add the correct corner piece.
3. Look up the corresponding direction change and multiply.
4. Step once and add the correct straight piece. (Don't need to step if we turn around.)
5. Repeat until done.
6. Step and add the arrow piece.
7. Print the grid.
**Code explanation (out of date, will fix later)**
```
P=Math::PI/2 # Save PI/2
b=0i;d=1 # Set initial coordinates and direction
c={b=>?:} # Create grid with starting `:`
gsub(/[1-4]/){x=$&.to_i # For each number 1-4
c[b+=d]="╗╝╚╔╗"[d.arg/P+x%2]if x[1]>0 # If 2-3 (second bit is a 1), step and write the corner piece
# If turning left (3), +1 to the index
d*=[0,1,1i,-1i,-1][x] # Multiply direction to turn accordingly
c[b+=d]="═‖"[d.imag.abs] # Step and write the straight piece
} # (end the loop)
c[b]=">V<^"[d.arg/P] # Write the corresponding arrow piece
q=c.keys.map &:rect # Get the filled-in grid spaces as X,Y coordinates
i,*_,j=q.map(&:first).sort # Find the min and max X coordinate
k,*_,l=q.map(&:last).sort # Find the min and max Y coordinate
puts (k..l).map{|y| # For each Y coordinate in range
(i..j).map{|x| # For each X coordinate in range
c[x+y*1i]||' ' # Get the character, or space if not present
}*'' # Join characters on that Y coordinate and print
}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~78~~ 73 bytes
```
4LÃ3ÝÐ<T**‡D₁Í«S4Ê>ćVs.¥Ì8%•2ß1Í'£Jθ•14вsxs¦©;+èŽb[+ç':š"^>V<"®;θ誮₂YèšΛ
```
[Try it online!](https://tio.run/##AYQAe/9vc2FiaWX//zRMw4Mzw53DkDxUKirigKFE4oKBw43Cq1M0w4o@xIdWcy7CpcOMOCXigKIyw58xw40nwqNKzrjigKIxNNCyc3hzwqbCqTsrw6jFvWJbK8OnJzrFoSJePlY8IsKuO864w6jCqsKu4oKCWcOoxaHOm///NP8tLW5vLWxhenk "05AB1E – Try It Online")
Explanation:
```
# The canvas built-in takes 3 arguments: lengths, strings to draw, and angles.
# First, we map the input to a list of angles, coded as multiples of 45°:
# Forward = 0, right = 2, U-turn = 4, left = 6.
# Conveniently, 4 already means U-turn in the input format.
# Since each turn is implicitly followed by a step in the new direction,
# we actually want to map 2 to [2, 0] and 3 to [6, 0].
4L # range 1..4
à # remove everything else from the input
3Ý # range 1..3
Ð # triplicate
< * # multiply one copy by the other -1
T* # multiply by 10
# stack is now [filtered input, [1, 2, 3], [0, 20, 60]]
‡ # transliterate: 1 => 0, 2 => 20, 3 => 60
# Now we compute the lengths. 05AB1E's canvas is a bit finnicky: to get the
# desired output, we need to use length 2 for each character, except right
# before U-turns and at the end, where we want length 1.
D # copy the list of angles
₁Í« # append 254
S4Ê # != 4 over each digit
> # increment each
ćV # remove the first element, save it in Y
s # swap so the list of angles is at the top again
# Cconvert relative angls to absolute angles.
# 05AB1E's 0 is up, but the default direction is right, so we start at 2.
.¥ # undelta (eg [6, 0, 4] => [0, 6, 6, 10])
Ì # add 2 to each
8% # modulo 8
# Now, we find the character to print at each step using a lookup table.
# For each pair of directions, we compute the index = first / 2 + second * 2.
# This maps each pair to a unique integer in 0..15.
•2ß1Í'£Jθ•14в # compressed list: [1,4,1,7,13,0,7,0,1,10,1,13,10,0,4,0]
s # swap
x # * 2 without popping
s # swap (yes we're doing that a lot...)
¦ # remove the first element
© # save in variable `r` without popping
; # / 2
+ # sum
è # index into the lookup table
Žb[+ # add 9552
ç # map codepoints to characters
':š # prepend a ":"
®;θ # half of the last angle
"^>V<" è # nth character of "^>V<"
ª # append
# If the first command is 4, the initial angle should be 6, otherwise 2.
® # push list of angles
₂Yè # Yth digit of 26 (we set Y earlier, remember)
š # prepend
# Finally, call the canvas built-in:
Λ
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~129~~ ~~126~~ ~~120~~ 118 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Žb_3Ý3*+ΣŽBÙNè}U4LÃ23SD1«‡©D4Å?Vε¾ˆ3%iŽb[D>‚¾èy≠i¼¼}ëy<iX¾è¼ëXÀ¾è.¼]¾ˆç':š®õQi`ë">V<^"¾èªDgÅ2¯¥2Q1Ý«-ćY+šsŽ9¦¯èYi¦6š}Λ
```
Sigh.. what a mess. Almost don't want to post it, but took too much time to not post it now. The challenge has quite a bit of edge cases I wasn't expecting when I started with it.. Can definitely be golfed (by a lot), though.
-3 bytes thanks to *@Grimy*.
-2 bytes by using `║` (unicode value 9553) instead of `‖` (unicode value 8214). If this is not allowed, 2 bytes has to be added again.
[Try it online.](https://tio.run/##yy9OTMpM/f//6N6keOPDc421tM8tPrrX6fBMv8MrakNNfA43GxkHuxgeWv2oYeGhlS4mh1vtw85tPbTvdJuxaiZQU7SL3aOGWYf2HV5R@ahzQeahPYf21B5eXWmTGQESO7Tn8OqIww0gpt6hPbEgbYeXq1sdXXho3eGtgZkJh1cr2YXZxCmB1a5yST/canRo/aGlRoGGh@ceWq17pD1S@@jC4qN7LQ8tO7T@8IrIzEPLzI4urD03@/9/C414W0MjFzMjZQdDx2BzFyNjY0Vj4@DkdBdDQxMXU8e0xGJHN/P/urp5@bo5iVWVAA) (No test suite for all test cases at once, because there is no way to reset the Canvas, so outputs would overlap..)
**Explanation:**
```
Žb_ # Push the compressed integer 9556
3Ý # Push the list [0,1,2,3]
3* # Multiplied by 3: [0,3,6,9]
+ # Added to the integer: [9556,9559,9562,9565]
Σ } # Sort it:
ŽBÙNè # Based on the order in the compressed integer 3021
# (so it's now in the order [9559,9565,9562,9556] ("╗╝╚╔"))
U # Then pop and store it in variable `X`
4L # Push a list [1,2,3,4]
à # And only keep those digits from the (implicit) input-string
23S # Push [2,3]
D1« # Duplicate it, and append a 1 to each: [21,31]
‡ # Replace all "2" with "21" and all "3" with "31"
© # Store the string in variable `r` (without popping) to use later on
D4Å? # Check if it starts with a 4 (without popping by duplicating first)
V # Pop and store it in variable `Y` to use later on
ε # Map over each digit:
¾ˆ # Add counter `c` to the global array
# (counter `c` is 0 by default)
3%i # If the current digit is a 1 or 4:
Žb[ # Push compressed integer 9552
D>‚ # Pair it with it's increment: [9552,9553] ("═║")
¾è # And index the counter `c` into it
y≠i } # If the current digit is NOT 1 (so it's a 4):
¼¼ # Increase counter `c` twice to reverse the direction
ëy<i # Else-if the current digit is a 2:
X¾è # Index the counter `c` into the list of variable `X`
¼ # And increase the counter `c` by 1
ë # Else (the current digit is a 3):
X # Push the list of variable `X`
À # Rotated it once toward the left: [9565,9562,9556,9559] ("╝╚╔╗")
¾è # Index the counter `c` into it again
.¼ # And decrease counter `c` by 1
] # Close all if-else statements and the map
¾ˆ # And also add the current counter `c` to the global array after the map
ç # Now convert all integers to ASCII characters with these unicode values
':š '# Prepend a ":" to this list
®õQi # If the input we saved in variable `r` was empty:
` # Push (and implicitly output) this single ":" as result
ë # Else:
">V<^"¾è # Index the counter `c` in the string ">V<^"
ª # And append it to the list
Dg # Get the length of the list (without popping by duplicating first)
Å2 # Create a list with that many 2s
¯¥ # Push the deltas/forward differences of the global array
2Q # Check if a delta is equal to 2 (which means we reversed direction)
# (1 if truthy; 0 if falsey)
1Ý« # Append a trailing [0,1]
- # Subtract them from the list of 2s
Y # If the input started with a 4:
ć +š # Increase the very first integer by 1 (from 1 to a 2)
s # Swap this integer list for the lengths and string list on the stack
Ž9¦ # Push compressed integer 2460
¯è # Index each value of the global array into it
Yi } # If the input started with a 4:
¦6š # Replace the first integer with a 6
Λ # Use the Canvas builtin (which is output immediately implicitly)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Žb_` is `9556`; `ŽBÙ` is `3021`; `Žb[` is `9552`; and `Ž9¦` is `2460`.
As for a brief explanation of the Canvas builtin `Λ` and its three arguments:
**First argument: length(s):** the sizes of the lines we want to draw. Since we have to keep in mind overlapping, we use size `2` for every character, except if we reverse the direction and we want to overlap or for the final character (one of `>V<^`), for which we'll use size `1` instead.
**Second argument: string(s):** the characters we want to display. Which are the characters in this case, with the prepended `:`, and if the input wasn't empty/`0` the appended appended final character (one of `>V<^`).
**Third argument: direction(s):** the directions these character-lines of the given length should be drawn in. In general we have the directions `[0,7]` which map to these directions:
```
7 0 1
↖ ↑ ↗
6 ← X → 2
↙ ↓ ↘
5 4 3
```
Which is why we have the integer `2460` for the directions \$[→,↓,←,↑]\$ respectively.
[See this 05AB1E tip of mine for a more detailed explanation about the Canvas builtin `Λ`.](https://codegolf.stackexchange.com/a/175520/52210)
] |
[Question]
[
*Inspired (like 2 others) by [this](https://chat.stackexchange.com/transcript/message/38713104#38713104) chat message. (and to some extent, my [CMC](https://chat.stackexchange.com/transcript/message/38713335#38713335))*
Given a string as an input, your task is to check whether or not that string is a number.
## What is a number?
This is a list of all input formats that are "numbers":
* Integers: An integer is a string made entirely of characters from `1234567890`, without any other character e.g. `152`
* Floats: A float is a integer with 1 (no more, no less) decimal points (`.`) in the middle of the number. A decimal point must always be preceded and followed by a number e.g. `1.0` or `3.14`
* Complex: A complex number is a number that follows the format `a+bj` where `a` and `b` are numerical values. The plus sign can also be a minus sign e.g. `1+10j` or `143-1j`. If it saves bytes (or you want to), you may use `i` instead of `j`.
* Longs: A long is any number that would be classed as an integer or a float, with an `L` at the end e.g `1325963L`
* Hexadecimal: A hexadecimal number is a number which consists entirely of characters in `1234567890abcdef`. Upper case characters are valid hex, but only when used consistently e.g. `10a` or `afa` not `A5c`
* Scientific: A scientific number is a number which consists of a run of digits (`1234567890.`) followed by an `e` followed by a run of digits, optionally preceded by a `-`. A `E` may also be used.
Any of these 5 may also be preceded by a minus sign (`-`) but any whitespace in the number causes it to no longer be a number e.g. `-3.5 + 2i` isn't a number. Longs may not be hexadecimal but may be floats
You must output 2 distinct values (preferably truthy and falsy but you may choose) for inputs that are either numbers as defined above, or not.
## Test Cases
These should result in truthy
```
10
-9.34
-3.5+2j
ab1
100000L
3.14159L
-73e-7
7E53C80
1.2e3
12E3.4
```
And these should be falsy
```
abcdefghijklmnop
10.10.10
2569LL
10L+9j
8+45io
4aE3
3.
.3
```
Now because small numbers are easier to work with, this is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code, *in bytes*, wins!
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~53~~ ~~52~~ 50 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
O[►~hΘP█⁵\↔<sK⁹>¼⅝┘d⁾Δo≡7ξδ¾▓↑ΧGj4<eu╝t┼Pπ»‘øβ!d!-
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=TyU1QiV1MjVCQSU3RWgldTAzOThQJXUyNTg4JXUyMDc1JTVDJXUyMTk0JTNDc0sldTIwNzklM0UlQkMldTIxNUQldTI1MThkJXUyMDdFJXUwMzk0byV1MjI2MTcldTAzQkUldTAzQjQlQkUldTI1OTMldTIxOTEldTAzQTdHajQlM0NldSV1MjU1RHQldTI1M0NQJXUwM0MwJUJCJXUyMDE4JUY4JXUwM0IyJTIxZCUyMS0_,inputs=LTMuNSsyag__) or [test all test cases](https://dzaima.github.io/SOGLOnline/?code=LiU3QiUyQyUzQURUQG8lMjJPJTVCJXUyNUJBJTdFaCV1MDM5OFAldTI1ODgldTIwNzUlNUMldTIxOTQlM0NzSyV1MjA3OSUzRSVCQyV1MjE1RCV1MjUxOGQldTIwN0UldTAzOTRvJXUyMjYxNyV1MDNCRSV1MDNCNCVCRSV1MjU5MyV1MjE5MSV1MDNBN0dqNCUzQ2V1JXUyNTVEdCV1MjUzQ1AldTAzQzAlQkIldTIwMTglRjgldTAzQjIlMjFkJTIxLW8_,inputs=MjElMEExMCUwQS02NCUwQS05LjMzJTBBLTMuNSsyaiUwQTMrNWolMEFBQjElMEExMDAwMDBMJTBBMy4xNDE1OUwlMEEtNzNlLTclMEE3RTUzQzgwJTBBMS4yZTMlMEExMmUzLjQlMEElMEFhYmNkZWZnaGlqa2xtbm9wJTBBMTAuMTAuMTAlMEEyNTY5TEwlMEExMEwrOWolMEE4KzQ1aW8lMEE0YUUzJTBBMy4lMEEuMw__) (first number indicates amount of test cases)
based on a regex - `^(-?\d+((\.\d+|)(L|e-?\d+(\.\d+|)|\+\d+(\.\d+|)j|)|)|[A-F\d]+)$`
[Answer]
# Javascript, ~~72~~ ~~71~~ 65 bytes
*saved one byte thanks to @Cowsquack*
*saved 6 bytes thanks to @dzaima*
```
a=>/^(-?\d+((\.\d+|)(L|e-?\d+(\.\d+|)|\+\d+(\.\d+|)j|)|)|[A-F\d]+)$/.test(a)
```
JS port of @dzaima's answer. Credit to @dzaima for the regex.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~290~~ ~~136~~ 105 bytes
Python port of @dzaima's answer. All credit to @dzaima for the regex :)
```
lambda s:re.match('^(-?\d+((\.\d+|)(L|e-?\d+(\.\d+|)|\+\d+(\.\d+|)j|)|)|[A-F\d]+|[a-f\d]+)$',s)
import re
```
[Try it online!](https://tio.run/##TY3daoQwEIXv5ymCLJiQJmyM1lUopRR7lTcwu5Bd4xrrH@pNwXe32bYXHQbOnA/OmelrbcZB7vWL3jvTXyuDlny2vDfrrcHhBbNXXVGMNfeyEaw2@0v@wKbpP9d6QLbyjX3o6ky30rD6cZBD@LQQcP00ziua7V6PM3LIDSgIAhBHYBmXMTDJExq1YK7Cw8cokFzEIskUsFRalkJaJPL9dATBIytBRIXksQ/cKlvfG9d@dv0wTj7Nfxai5DlTyntFsxZONE7cCLEppC8GLsH/L0XOxJkvU@dWHOohJDmaZjesuMaOkP0b "Python 3 – Try It Online")
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/89324/edit).
Closed 7 years ago.
[Improve this question](/posts/89324/edit)
# Challenge description
*Multiplification* (totally not a made-up word) is a process in which you take two positive integers: `a` and `b`, and produce another integer which is equal to `a` repeated ("glued together") `b` times. For example, multiplifying `3` by `7` gives `3333333`. Similarly, `103` multiplified by `5` is `103103103103103`.
In this challenge, given two positive integers `a` and `b`, output `a` multiplified by `b`. The catch is, you can't use string operations to generate the number - it has to be done in a purely mathematical way. You may only use operators for addition (`+`), subtraction (`-`), multiplication (`*`), integer division (`/`, `//`, `div`), modulo operation (`%`, `mod`) and binary operations (`&`, `^`, `|`, `<<`, `>>` etc.). It's not possible to do in every language, since it has to support arbitrary precision integers.
# Sample inputs / outputs
```
10, 4 | 10101010
3, 9 | 333333333
3737, 2 | 37373737
993, 1 | 993
8888, 8 | 88888888888888888888888888888888
```
[Answer]
## Python 2, 48 bytes
```
c,n=input();a=1
while n/a:a*=10
print a**c/~-a*n
```
Arithmetic!
Take number `n` and repetition count `c`. First, computes `a=10**num_digits(n)` as the smallest power of 10 above `a`. Then, the floor division `a**c/(a-1)` gives a number of the form `1001001001001` with `c` ones, spaced apart by the digit-length of `n`. Multiplying by `n` then replaces each `1` with `n`, giving `c` concatenated copies of `n`.
A same-length recursive version:
```
f=lambda c,n,a=10:a**c/~-a*n*(a>n)or f(c,n,a*10)
```
This one has to start at `a=10` because `a=1` causes a division-by-zero error.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 9 bytes
```
jL,?h:.cL
```
[Try it online!](http://brachylog.tryitonline.net/#code=akwsP2g6LmNM&input=WzEwOjRd&args=Wg)
### Explanation
The `j` operator concatenates the first thing in an array to itself as many times as the second thing in the array.
In other words, `[10:2]` would produce `101010`.
This operator uses integer in the implementation so is completely usable.
However, it is one concatenation too many.
Therefore, we use the ability of Brachylog to prove things to deal with this:
```
jL,?h:.cL
jL input after being treated by the j operator yields L
, and
?h:.cL first element of input concatenated with output is L
```
[Answer]
## Java 8 lambda, 268 characters
Arbitrary precision ruins everything, here are the BigIntegers:
```
import static java.math.BigInteger.*;import java.math.BigInteger;(a,b)->{BigInteger r=ZERO;int d=(int)(Math.log(2)/Math.log(10)*a.bitLength()+1);if(TEN.pow(d-1).compareTo(a)>0)d--;while((b=b.subtract(ONE)).compareTo(ZERO)>=0)r=r.multiply(TEN.pow(d)).add(a);return r;}
```
And here the ungolfed version:
```
import java.math.BigInteger;
import static java.math.BigInteger.*;
public class Q89322 {
static BigInteger expand(BigInteger a, BigInteger b) {
BigInteger result = ZERO;
int digitCount = (int) (Math.log(2) / Math.log(10) * a.bitLength() + 1);
if (TEN.pow(digitCount - 1).compareTo(a) > 0) {
digitCount--;
}
while ((b = b.subtract(ONE)).compareTo(ZERO) >= 0) {
result = result.multiply(TEN.pow(digitCount)).add(a);
}
return result;
}
}
```
I hope that logarithm is also counted as a valid mathematical operation :)
Getting the digits of the BigIntegers powered by [this guy](https://stackoverflow.com/a/23773083/3764634). With only `int` or `long` this could be way shorter :/
[Answer]
## Haskell, 38 bytes
```
n%c|a<-until(>n)(*10)1=n*div(a^c)(a-1)
```
Everyone forgets about `until`!
[Answer]
# PHP, ~~105~~ ~~139~~ ~~136~~ 134 bytes
```
function m($a,$b){$s=$x=$a;for($f=10;$x>9;$x=bcdiv($x,10))$f=bcmul($f,10);for(;$b=bcsub($b,1);)$s=bcadd($s,$a=bcmul($a,$f));return$s;}
```
arbitrary precision needs some room in PHP, but I´ll look if I can shrink this a bit.
[Answer]
# Python, 65 bytes
```
f=lambda x,n,p=1:p<=x and f(x,n,p*10)or n and f(x,n-1,p)*p+x or 0
```
[Ideone it!](http://ideone.com/7xCwpd)
First recursion to find the power, second recursion to complete the "concatenation".
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 bytes
```
i*jQTET
```
[Test suite.](http://pyth.herokuapp.com/?code=i%2ajQTET&test_suite=1&test_suite_input=10%0A4%0A3%0A9%0A3737%0A2%0A993%0A1%0A8888%0A8&debug=0&input_size=2)
Convert to digit list, repeat for that many times, then convert to number.
```
i*jQTET Q: first input, E: second input
jQT convert Q to base T (10) as a digit list
* E repeat for E many times
i T convert from digit list to number
```
[Answer]
## JavaScript (ES7), 43 bytes
```
f=(a,b,c=1)=>c>a?(c**b-1)/~-c*a:f(a,b,c*10)
```
Works up to `f(9000,4)`. (Looks like I rediscovered @xnor's formula.) 56-byte ES6 version or 52-byte ES6 version with an even smaller range:
```
f=(a,b,c=0,d=0)=>c<a?f(a,b,c*10+9,d*(b='1e'+b)+--b):d/c*a
f=(a,b,c=1,d=1)=>c>a?~-d/~-c*a:f(a,b,c*10,d*='1e'+b)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
DẋḌ
```
[Try it online!](http://jelly.tryitonline.net/#code=ROG6i-G4jA&input=&args=MTA+NA)
```
DẋḌ Main chain, argument: x,y
D Convert x to list of digits
ẋ repeat y times
Ḍ Convert back to number
```
[Answer]
## Common Lisp, 73 bytes
```
(lambda(a b)(loop for x below b sum(*(expt 10(*(ceiling(log a 10))x))a)))
```
[Answer]
# k, 20 bytes
Same idea as **Pyth** solution.
Only supports up to 64 bit signed int range.
```
{10/:(y*#d)#d:10\:x}
```
Example
```
k){10/:(y*#d)#d:10\:x}[103;2]
103103
```
] |
[Question]
[
**Winner**
[CJam, 74 bytes](https://codegolf.stackexchange.com/a/38421/31300) by Optimizer
**Task**
* Take an input of an integer `n` through the console or a file.
* Find the sum of the `n`th prime, square, triangular number, and cube. Add to that the factorial of the first decimal place of the square root of `n` and the `x`th Fibonacci number, where `x` is the first digit of the square of `n`.
* Print that sum to the console or to a file.
**Rules**
* Entries must complete the task above for all positive integers less than 100.
* Standard loopholes are of course not allowed.
* Any built-in function that finds primes or tests for primes in any way is not allowed.
* This is code golf.
**Summary of numbers to sum**
```
nth prime (where 2 is the first)
square of n
nth triangular number (where 1 is the first)
cube of n
factorial of the first decimal place of the square root of n
xth Fibonacci number, where x is the first digit of the square of n (2 is the third Fibonacci number)
```
**Examples**
Note: The numbers being summed are included here just for clarity.
```
Input: 1
Output: 2 + 1 + 1 + 1 + 1 + 1 = 7
Input: 11
Output: 31 + 121 + 66 + 1331 + 6 + 1 = 1556
Input: 99
Output: 523 + 9801 + 4950 + 970299 + 362880 + 34 = 1348487
```
[Answer]
## Java, 323
```
class C {public static void main(String[]s){int n=new java.util.Scanner(System.in).nextInt(),p=2,j,k=1,t=0,a=1,b=0,c;z:for(;t<n;p++){for(j=1;++j<p;)if(p%j<1)continue z;t++;}j=(int)Math.round(Math.sqrt(n)%1*10);for(t=0;t++<j;k*=t);for(c=j=n*n;(j/=10)>9;);for(t=0;++t<j;a+=b,b=a-b);System.out.print(p-1+c+(c+n)/2+c*n+k+a);}}
```
Ungolfed:
```
class C {
public static void main(String[] args) {
int n = new java.util.Scanner(System.in).nextInt(), p = 2,
j,
k = 1,
t,
a = 1,
b = 0,
c;
// prime
z:
for (t = 0; t < n; p++) {
for (j = 1; ++j < p; ) {
if (p % j < 1) {
continue z;
}
}
t++;
}
// factorial
j = (int) Math.round(Math.sqrt(n) % 1 * 10);
for (t = 0; t++ < j; k *= t);
// fibonacci
for (c = j = n * n; (j /= 10) > 9;);
for (t = 0; ++t < j; ) {
a += b, b = a - b);
}
System.out.print(p - 1 + c + (c + n) / 2 + c * n + k + a);
}
}
```
[Answer]
## CJam, ~~83 76 75~~ 74 bytes
This can be golfed more. Will update when I golf it further.
```
T1{_2$+}A*]ri:NN*s1<i={X):Xmf,1=T+:TN<}gXNN*_N*N_)*2/Nmqs_'.#)=~,:)1+:*]:+
```
The online compiler for CJam does not return proper Double numbers(required by mq, root). So try it in the Java version as mentioned on [this](https://sourceforge.net/p/cjam/wiki/Home/) page
[Answer]
## Mathematica, ~~152~~ ~~136~~ ~~133~~ 132 bytes
```
For[n=Input[i=m=0],m<n,If[Divisors@++i=={1,i},m++]];#&@@Fibonacci@IntegerDigits[n^2]+i+3n^2/2+n/2+n^3+Floor[-10(Floor[s=Sqrt@n]-s)]!
```
I'm first determining the *n*th prime number in a loop (also avoiding `NextPrime` - it's not explicitly disallowed but I think it's not intended to be allowed either), and then I'm simply summing all the required numbers in a single expression. There is one simplification: I'm combining *n2* and the triangular number *n(n+1)/2* into *3n2/2* and *n/2*.
Input is taking via prompt, which is the closest thing to STDIN you get in Mathematica.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 159 bytes
```
n=>{
f=a=b=1
for(N=n**.5*10%10|0;N;)
f*=N--
for(N=(n*n+"")[0];--N;)
b=a+(a=b)
f+=a+n*(n*n+n+-~n/2)
for(i=2;n;n-=j<=i++)
for(j=1;++j<i;)
j=i%j?j:i
return f+i-1}
```
[Try it online!](https://tio.run/##ZYzLbsIwFET3/ooICcn2lSGXEh410@5Y5geqLgIkyBa6rgJ008evpy7tpupuNOfMxOa1Oe/78HJxkg7tsMUgeHhTHRrswKpLva4h1k4qy@WYy/fS196ozqJ27hdrsUKjkXkqn71z33iHhnR@yCLlKPamCLlPmc7MbRYw8@LFIW4QiH7KCPZEcRPyR0QYx8d4H1TfXq69FB0Fxx/DPsk5ndrJKR31Vq/XBuC7@Wq@Whr1lzGbAii4qhb/UF4tzfAF "JavaScript (Node.js) – Try It Online")
] |
[Question]
[
I have a script:
```
$ cat ~/zebra.pl
#!/bin/perl
use Term::ANSIColor;
$Term::ANSIColor::EACHLINE = "\n";
my $zebra = 1; # Are zebras black with white stripes, or white with black stripes?!
my $black = color('white on_black');
my $blue = color('white on_blue');
while (<>){
chomp($_);
$zebra = $zebra == 1 ? 0 : 1;
($zebra == 1 && print $blue) || print $black;
print $_;
($zebra == 1 && print $black) || print $blue;
print "\n";
}
print color('reset');
```
Usage:
```
some-command | zebra
```
The output consists of alternating lines that have black and blue backgrounds, respectively. The script seems needlessly long and complex. I'm wondering how much shorter it could be.
[Answer]
# Sed: 45 characters
```
1~2s/^/\e[40;37m/;2~2s/^/\e[44;37m/;s/$/\e[m/
```
Usage:
```
some-command | sed $'1~2s/^/\e[40;37m/;2~2s/^/\e[44;37m/;s/$/\e[m/'
```
[Answer]
# C#: 105 84
Easy. You just need some sort of marker, and your infinite loop. From there, things are rather easy.
(Assumes `using System;`, this is just a method body.)
```
bool b=false;while(true){Console.WriteLine((b?"Blue":"Black")+" background!");b=!b;}
```
[Answer]
# Awk: 56 52 characters
```
{x="\x1b[37;4";y=NR%2;print x (y?0:4)"m"$0x 4*y"m"}
```
```
{x="\x1b[37;4%dm";printf x"%s"x"\n",NR%2?0:4,$0,NR%2*4}
```
] |
[Question]
[
## This page is not for [Visual Basic Tips](https://codegolf.stackexchange.com/q/155838/61846 "Visual Basic Tips")
Visual Basic .NET (VB.NET) is an multi-paradigm dialect of [basic](/questions/tagged/basic "show questions tagged 'basic'") that was developed and released by Microsoft in 2002 as a replacement for Visual Basic. The current version of VB.Net as of Feb 2018 is Visual Basic .NET 15.0.
Unlike Visual Basic (VB), Visual Basic .NET (VB.NET) is fully integrated with the Microsoft .NET Framework giving it access to a far wider range of classes to access. Additionally, the bit width of integers and longs in VB.NET are `32` and `64` bits, respectively - twice that available to VB.
>
> Some helpful links
>
>
> * [MSDN Visual Basic .NET Guide](https://docs.microsoft.com/en-us/dotnet/visual-basic/ "Visual Basic .NET Guide - MSDN")
> * [Visual Basic .NET Wiki](https://en.wikipedia.org/wiki/Visual_Basic_.NET "Visual Basic .NET - Wikipedia")
> * [TIO - Visual Basic .NET (.NET Core)](https://tio.run/##K0vSTc4vSv0PBAA "Visual Basic .NET (.NET Core) – Try It Online")
> * [TIO - Visual Basic .NET (Mono)](https://tio.run/##K8ssLk3M0U1KLM5M1s1LLdHNzc/L/w8EAA "Visual Basic .NET (Mono) – Try It Online")
>
>
>
[Answer]
# `Dim` Variables implicitly as variants
VB.NET is capable of assuming object type at compile time - with numerics being dimmed into 32-bit spaces this means that
```
Module M
Sub Main
Dim i As Byte
Dim j As Short
Dim k As Integer
Dim l As Long
For i=128To 2^8-1 Step 64
For j=2^7*i To 2^15-1 Step 64^2
For k=2^16*j To 2^31-1 Step 2^24
For l=2^31*k To 2^62-1 Step 2^48
Console.Write(i & j & k & l)
Next
Next
Next
Next
End Sub
End Module
```
[Try it online!](https://tio.run/##XZBNC4JAEIbv@yvmJCUY7GbmxUOfEGQXg25C5mCr226sa9SvN10Jocssz/u8DMy@Mu@mNLZtrPJGIMQkaTKIr1ySLX8Ah1UN649BS2VPyV1pY7Hq8SANFqhtIPrgqGRB9koDjygLzwpYGnoUEoNPCHxryoilS5eDlXQx2pRZX3WeBm45FOb0V2ApGxaIqI/daigEbCz4IdkoWSuBs4vmBiccnBKcChwxJSd8m/@xkzl0J9t3@IO2/QI "Visual Basic .NET (.NET Core) – Try It Online") (266 bytes)
May be trimmed down by `dim`ming `i`, `j`, `k` as variants, (note that because the default numeric type of a variant is a 32 Bit `Integer` `l` must still be `dim`med as a `Long` as it shall hold a 64 bit value)
```
Module M
Sub Main
Dim i,j,k,l As Long
For i=128To 2^8-1 Step 64
For j=2^7*i To 2^15-1 Step 64^2
For k=2^16*j To 2^31-1 Step 2^24
For l=2^31*k To 2^62-1 Step 2^48
Console.Write(i &j &k &l)
Next
Next
Next
Next
End Sub
End Module
```
[Try it online!](https://tio.run/##XY87C8IwFIX3/Io7FS2tkFhrlg7iY7IuFdwC1gbJw0T6EP99rAlScDkXzvdx4bzq9GZb7lxpm0FzKFE11FBehUE78QCRyEQlGjYdHK25o4NtQRSY0LMFwmiKoer5E/LME1kQto4FeIhXE2XEczVynMcyCEv8Ewgj4YEuvnWsgpCTScgo2lrTWc0Xl1b0fCYgkhApiPQcnfi7/4@9aWCc4m/Y5twH "Visual Basic .NET (.NET Core) – Try It Online") (226 bytes)
or even further to 218 bytes by combining `Next` statements
```
Module M
Sub Main
Dim i,j,k,l As Long
For i=128To 2^8-1 Step 64
For j=2^7*i To 2^15-1 Step 64^2
For k=2^16*j To 2^31-1 Step 8^8
For l=2^31*k To 2^62-1 Step 2^48
Console.Write(i &j &k &l)
Next l,k,j,i
End Sub
End Module
```
[Try it online!](https://tio.run/##Rc87C8IwFAXgPb/iTkVLKyTWmqWD@JisSwW3gLVBbhIT6UP897GmiNOF@53hnFed3lwrvS9dMxgJJamGGsorWrLDB2CiEp0Y2HRwdPZODq4FLCjjZwdM8JRC1csn5FkQVTCxjhEC0tVfBQuuR6d5rKbAkv4CXPDgpvh@Yz15zn7ORMbJ1tnOGbm4tNjLGUKkINIQmTk5yXcPZuypEiR728A4Idxpk/cf "Visual Basic .NET (.NET Core) – Try It Online") (218 bytes)
For a total savings of 40 bytes without impacting the output.
[Answer]
# Combine `Dim` Statements
The VB6 command
```
Dim i As Double
Dim j As Double
Dim k as Double
Dim l As Double
```
Can be rewritten as
```
Dim i,j,k,l as Double
```
Note that this is dissimilar from VB6 where only `l` would be defined as a double and `i,j,k` would be defined as variants.
[Answer]
# `Imports` keyword
You can use the `Imports` keyword in order to save bytes when using multiple class methods or a class method multiple times
## 92 bytes
```
module e
sub main
console.write(console.readline)
console.writeline("hi")
end sub
end module
```
## 91 bytes
```
imports system.console
module e
sub main
write(readline)
writeline("hi")
end sub
end module
```
] |
[Question]
[
**This question already has answers here**:
[Case Permutation](/questions/80995/case-permutation)
(24 answers)
Closed 6 years ago.
# Challenge
For any string that is composed of alphabetical characters of any case, make a function that returns a list of all of it's variations, order and case-wise empty strings returns empty list.
# Test Cases
```
"" -> []
"a" -> ['a', 'A']
"ab" -> ['ab', 'Ab', 'aB', 'AB', 'ba', 'Ba', 'bA', 'BA']
"abc" -> ['abc', 'Abc', 'aBc', 'ABc', 'abC', 'AbC', 'aBC', 'ABC', 'bac', 'baC', 'bAc', 'bAC', 'Bac', 'BaC', 'BAc', 'BAC', 'CBa', 'CBA', 'cba', 'cbA', 'cBa', 'cBA', 'Cba', 'CbA', 'caB', 'cAb', 'cAB', 'cab', 'CaB', 'CAb', 'CAB', 'Cab', 'Acb', 'AcB', 'acb', 'acB', 'aCb', 'aCB', 'ACb', 'ACB', 'Bca', 'BcA', 'bca', 'bcA', 'bCa', 'bCA', 'BCa', 'BCA']
'aa' -> ['aa', 'Aa', 'aA', 'AA'] (for duplicate letters extra, duplicate permutations are allowed if necessary)
```
As the permutations rack up quickly **you only need to handle up to 4 ASCII letter chars.**
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins!
[Answer]
# [Python 2](https://docs.python.org/2/), 89 bytes
```
lambda s:map(list,map(permutations,product(*zip(s.swapcase(),s))))
from itertools import*
```
[Try it online!](https://tio.run/##NYoxDsIwDEV3TpEtblUxMCKxcAukLqZNhKUktmJXQC8fghB/el/vydseXE4tXuaWMN9XdHrOKJBIbfqChJo3QyMuOknldVsMxp0E9KhPlAU1wDDp0HeIlbMjC9WYkzrKwtXGJpWKQQSPV9@r3/Vz8X/uan/dumsf "Python 2 – Try It Online")
Doesn't work in Python 3. Swap case idea from HyperNeutrino.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
żŒsp/Œ!€Ẏ
```
[Try it online!](https://tio.run/##ASEA3v9qZWxsef//xbzFknNwL8WSIeKCrOG6jv/Dh1n//yJhYiI "Jelly – Try It Online")
# Explanation
```
żŒsp/Œ!€Ẏ Main Link
ż zip each character with
Œs its case swapped
p/ reduce over cartesian product
€ for each sublist
Œ! find all permutations
Ẏ flatten by one layer
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
Œu,ŒlZŒpŒ!€
```
[Try it online!](https://tio.run/##AR8A4P9qZWxsef//xZJ1LMWSbFrFknDFkiHigqz///8iYWIi "Jelly – Try It Online")
**16** **bytes** if we need formatting and no repeated permutations.
```
Œu,ŒlZŒpŒ!€;/QŒṘ
```
[Try it online!](https://tio.run/##AScA2P9qZWxsef//xZJ1LMWSbFrFknDFkiHigqw7L1HFkuG5mP///yJhYiI "Jelly – Try It Online")
This is assuming (a) we need delimiters between the permutations (achieved by `ŒṘ` at the end) and (b) the input `'aa'`-->`['AA','Aa','aA','aa']` and doesn't count the two 'a's as unique, which would give the same answer but each permutation would appear twice.
**Explanation**
```
Œu,ŒlZŒpŒ!€;/QŒṘ Main link
Œu Upper case. 'aB'->'AB'
Œl Lower case. 'aB'->'ab'
, Pair dyad. -> [['A','B'],['a','b']]
Z Zip the columns. -> [['A','a'],['B','b']]
Œp Cartesian product of the elements in the outermost list. -> [['A','B'],['A','b'],['a','B'],['a','b']]
Œ!€ The permutations applied at €ach element in the list. -> [[['A','B'],['B','A']],[['A','b'],...
The rest is deleting duplicates and formatting.
;/ Concatenates the lists of permutations. In Essentially flattens the list by one level.
Q Remove repeated elements
ŒṘ Print in Python's string format
```
[Answer]
# JavaScript (ES6), 169 bytes
I/O format: arrays of characters.
```
a=>(r=[],P=(a,m=[])=>a.map((_,i)=>P(b=[...a],[...m,...b.splice(i,1)]))>[]||(g=i=>i>>m.length||g(-~i,r.push(m.map((c,j)=>c[`to${i>>j&1?'Upp':'Low'}erCase`]()))))())(a)&&r
```
Not the right tool for the job... Still, there's probably a golfier way.
### Demo
```
let f =
a=>(r=[],P=(a,m=[])=>a.map((_,i)=>P(b=[...a],[...m,...b.splice(i,1)]))>[]||(g=i=>i>>m.length||g(-~i,r.push(m.map((c,j)=>c[`to${i>>j&1?'Upp':'Low'}erCase`]()))))())(a)&&r
f([...'abc']).forEach(a => console.log(a.join('')))
```
] |
[Question]
[
This is a more difficult version of [It's a find-a-movie challenge](https://codegolf.stackexchange.com/questions/143772/its-a-find-a-movie-challenge) .
**Input**
Your code should take [a BBFC rating](http://uk.ign.com/wikis/content-ratings/BBFC) and a number from 1 to 5 as input. It can do this in any way you find convenient.
**Output**
Your code should return the name of any movie which has a) that film rating and b) that number of stars in a [Guardian film review](https://www.theguardian.com/film+tone/reviews).
If there is no such movie it can output anything you like.
The possible BBFC film ratings are `U, PG, 12, 12A, 15, 18, R18, TBC`.
Your code may report one or more movies, that is up to you.
To clarify, your code is meant to access the web to get the answers to queries.
**Example**
Say the input is `U, 5` then your code could output "My Neighbour Totoro".
Please show an example of your code working with the film rating `PG` and score `4` along with your answer.
**Notes**
The Guardian does have an API but this requires registration. For this challenge you may not use it.
**Example code**
The following Python 3 code gets all the movies along with their score out of 5, although not 100% perfectly.
```
from bs4 import BeautifulSoup
import requests
import sys
for i in range(1,837):
print("Page", i,file=sys.stderr)
result = requests.get("https://www.theguardian.com/film+tone/reviews?page={0}".format(i))
data = result.text
soup = BeautifulSoup(data, "lxml")
tags = soup.find_all("div", {"class":"stars"})
for tag in tags:
stars = 0
for star in tag.find_all("span", {"class":"star__item--grey"}):
stars +=1
main = tag.parent
title = main.find("h2")
if title:
a = title.find("span", {"class":"js-headline-text"})
print("{} - {}".format(5 - stars, a.text))
```
[Answer]
# NodeJS
I'm an awful golfer tho
The inputs must be passed like this `node filename 12,12A,15,18 4` for fetching a movie with one of the ratings comma separated and at least 4 stars
```
var fetch=require('node-fetch');
var {JSDOM, VirtualConsole}=require('jsdom');
var f=x=>fetch(x).then(r=>r.text());
var vc = new VirtualConsole(); // ignore annoying css errors
var [bbfc='U,PG,12',stars='3']=process.argv.slice(2);
var Z=async()=>{
for(var i=0;i<10;i++){ // 10 max pages, can be anything
var t= await f(`https://www.theguardian.com/film+tone/reviews?page=${i}`);
var w=new JSDOM(t, {virtualConsole:vc}).window;
for(var h of w.document.querySelectorAll('.fc-item__header')){
if (h.querySelectorAll('.star__item--golden').length>=stars){
var title=h.querySelector('.js-headline-text').textContent.split(' review')[0].trim();
var t=await f('http://www.bbfc.co.uk/search/releases/'+title);
var rating=t.match(/BBF\w_(\w+)_/)[1];
if(bbfc.includes(rating)) return title;
}
}
}
};
Z()
.then(console.log)
.catch(console.error)
```
[Answer]
# Javascript/JQuery - ~~517~~ ~~504~~ 494 bytes
Not really golfed at all, just wanted to write an answer.
```
x=>y=>{t=n=i=1;f=()=>{if(t){$.get("https://www.theguardian.com/film+tone/reviews?page="+i,d=>{l=$(d).find("div.stars").toArray().slice(1);for(k=0;k<l.length&&t;k++){((j,m)=>($.get('http://www.bbfc.co.uk/search/releases/'+encodeURI(n=$(m[j].parentNode).find("h2 span.js-headline-text").text().split(" review")[0]),(p=>b=>{if(/BBFC_(.*?)_/.exec($(b).find(".symbol img")[0].src)[1]==y&&$(m[j]).find(".star__item--golden").length==x){if(t)alert(p);t=0}})(n))))(k,l)}});i++;setTimeout(f,2000)}};f()}
```
It waits 10 sec before trying another page to stop the program from doing too many requests concurrently, so it may take some time with some inputs.
## Examples:
[](https://i.stack.imgur.com/wvNkM.png)
[](https://i.stack.imgur.com/0UUfb.png)
[Answer]
# Python + BS4 - 631 bytes
Lembik wanted a Python answer so he could run it, so I made one, but its way longer.
```
from bs4 import BeautifulSoup as b
import requests
def f(x,y):
i=n=1
while 1:
for m in b(requests.get("https://www.theguardian.com/film+tone/reviews?page="+`i`).text,'lxml').find_all('div',{'class':'stars'}):
a=m.parent.find('h2')
if a:
e=a.find('span',{'class':'js-headline-text'}).text.split(" review")[0]
s=b(requests.get('http://www.bbfc.co.uk/search/releases/'+requests.utils.quote(e)).text,'lxml').find("p",{"class":"symbol"})
if s and s.find("img").get('src').split("BBFC_")[1].split("_")[0]==y and len(m.find_all('span',{'class':'star__item--golden'}))==x:return e
i+=1
```
] |
[Question]
[
There are lots of challenges that just pick a sequence from oeis and ask you to print n-th number or first n numbers or whatever.
It's time to ~~stop~~ automate!
## Task
Your task is to parse a sequence page from [oeis.org](http://oeis.org/) and print its index, description and example values. The page's index should be chosen and random, selected uniformly from the range `[1-289361]`.
Example outputs (formatted with newline as a separator):
```
A034434
Multiplicity of highest weight (or singular) vectors associated with character chi_46 of Monster module.
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 3, 7, 12, 21, 38, 60, 102, 165, 265, 416, 660, 1015, 1574, 2405, 3665, 5535, 8364, 12512, 18726, 27862, 41391, 61240, 90541, 133381, 196395, 288534, 423656, 621219, 910885, 1334634
A38246
Triangle whose (i,j)-th entry is binomial(i,j)*5^(i-j)*4^j.
1, 5, 4, 25, 40, 16, 125, 300, 240, 64, 625, 2000, 2400, 1280, 256, 3125, 12500, 20000, 16000, 6400, 1024, 15625, 75000, 150000, 160000, 96000, 30720, 4096, 78125, 437500, 1050000, 1400000, 1120000, 537600, 143360, 16384, 390625
A212813
Number of steps for n to reach 8 under iteration of the map i -> <a href="/A036288" title="a(n) = 1 + integer log of n: if the prime factorization of n is n = Product (p_j^k_j) then a(n) = 1 + Sum (p_j * k_j) (cf. A...">A036288</a>(i), or -1 if 8 is never reached.
-1, -1, -1, -1, -1, -1, 1, 0, 2, 1, 2, 1, 3, 2, 3, 3, 4, 3, 3, 2, 3, 3, 3, 2, 3, 4, 2, 2, 4, 3, 4, 3, 4, 3, 4, 3, 5, 4, 5, 2, 5, 4, 5, 4, 2, 5, 3, 2, 4, 4, 4, 4, 3, 2, 5, 3, 4, 4, 5, 4, 5, 4, 3, 4, 4, 5, 5, 4, 3, 4, 5, 4, 4, 3, 3, 3, 4, 4, 4, 3, 4, 5, 5, 4, 4, 6, 5, 4, 4, 3, 4, 3, 5, 5, 4, 3, 6, 5, 4, 4, 5, 4, 4, 3, 4, 4, 4, 3, 5, 4, 6, 4, 5, 4, 5, 4, 3, 5, 4
A155181
a(n)=5*a(n-1)+a(n-2), n>2 ; a(0)=1, a(1)=4, a(2)=20 .
1, 4, 20, 104, 540, 2804, 14560, 75604, 392580, 2038504, 10585100, 54964004, 285405120, 1481989604, 7695353140, 39958755304, 207489129660, 1077404403604, 5594511147680, 29049960142004, 150844311857700, 783271519430504
A227356
Partial sums of <a href="/A129361" title="a(n) = sum{k=floor((n+1)/2)..n, F(k+1)}.">A129361</a>.
1, 2, 5, 10, 20, 36, 65, 112, 193, 324, 544, 900, 1489, 2442, 4005, 6534, 10660, 17336, 28193, 45760, 74273, 120408, 195200, 316216, 512257, 829458, 1343077, 2174130, 3519412, 5696124, 9219105, 14919408, 24144289
```
Example, ungolfed, python script:
```
import requests
import random
seq = 'A%s' % `random.randint(1,289361)`.zfill(6)
page = requests.get('http://oeis.org/%s' % seq)
print_next = False
content = []
for line in page.text.split('\n'):
if print_next:
print_next = False
content.append(line)
if '<td width="710' in line or '<td valign=top align=left>' in line:
print_next = True
print seq
print content[0].lstrip()
print content[1].lstrip()[4:-5]
```
## Rules
* [oeis.org](http://oeis.org/) states, that there are **289361** sequences right now. You should not try to parse pages with higher index.
* Your program should **uniformly** choose a random page.
* Your program may produced undefined behavior if it randomly chooses to parse an oeis page that is reserved or does not contain a sequence (see [A288145](http://oeis.org/A288145))
* Trailing white space is acceptable.
* You must remove leading white space and the outermost html tags from each line of your output. (i.e., the example values are wrapped in `<tt><tt/>`, which must be removed, but the description sometimes contains tags such as `<href>` within the text. Such tags do not need to be handled (see [A195534](http://oeis.org/A219225))).
* You do not have to handle html escapes (see [A219225](http://oeis.org/A219225))
* You do not need to print leading zeroes in the index. (e.g. A1 and A000001 are both acceptable). This is because [oeis.org](http://oeis.org/) itself allows you to do either, as in, <http://oeis.org/A1> and <http://oeis.org/A000001> are both valid URLs that point to the same page.
* You may return/print the "lines" in one of the following formats:
+ As an array/list with three elements
+ As a string separated by some separator. However, the separator **must not appear** in any of the "lines" (the index, the description, or the example values). In addition, this separator must be consistent (you can't select a separator based on the content of the "lines").
* The [meta definition of uniformly random](https://codegolf.meta.stackexchange.com/a/10923/56085) applies.
* [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code (in bytes) wins.
[Answer]
## CJam (61 bytes)
```
"oeis.org/search?fmt=text&q=id:A"289361mr)s+gN%{1=s"ISN"&},N*
```
No online demo available because the use of `g` is restricted by both online testers for security reasons.
I'm still not convinced that the output format is clearly specified, but since I seem to be in a minority I'm exploiting its gaps for golfiness. There is no leading whitespace or outer HTML tag to remove in the output.
[Answer]
# Python 3, 198 bytes
```
from requests import*
import random,html
s='A%s'%str(random.randint(1,289355))
print(s)
t=get('http://oeis.org/%s'%s).text.split('\n')
print(html.unescape(t[95].strip()))
print(t[116].strip()[4:-5])
```
This works for everything I've tried so far, but since it hard-codes the line indices, please tell me if it breaks on anything (that isn't an unfilled reserved spot).
-9 bytes thanks to Dead Possum
] |
[Question]
[
*[Related](https://codegolf.stackexchange.com/questions/51402/each-step-of-the-levenshtein-distance)*
Your goal, is to write a set of programs, that progresses from one to the other, one character at a time. For example. Given the starting program `abcd` and the ending program `wxyz`, you should have 5 valid programs, with the respective outputs.
```
abcd -> wbcd
wbcd -> wxcd
wxcd -> wxyd
wxyd -> wxyz
wxyz -> wxyz
```
As can be seen, the last program should be a quine.
## Rules
* Your start and end program may be any length, And they may also be different lengths
* Your start and end program must contain entirely unique characters at each position, but may share characters overall.
* Each program should affect a single character at a time, in any order, characters should only be added or removed from the end of the program.
* **None** of your programs need to follow the valid quine rules, they only need to output the correct string.
* [Standard Loopholes Apply.](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default)
## Scoring
Programs are scored by the length of the start program plus the length of the end program in bytes. In the previous example, `4 + 4 = 8`, so the score is eight. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest programs wins.
## Some Valid Programs
*In languages that hopefully don't exist*
```
abcd -> dbcd -> dccd -> dcbd -> dcba
a -> b
a -> b -> bc -> bcd -> bcde
ab -> aa -> ba
[BLANK PROGRAM] -> a
xyz -> xy -> x -> [BLANK PROGRAM]
```
[Answer]
# Retina, Score 1
```
```
[Try it online!](https://tio.run/##K0otycxL/A8EAA "Retina – Try It Online")
* The empty program outputs `1`, since the empty input matches the empty string exactly once.
* [`1` outputs `0`](https://tio.run/##K0otycxL/P/f8P9/AA), since `1` doesn't match the empty input.
* [`0` outputs `0`](https://tio.run/##K0otycxL/P/f4P9/AA), since `0` doesn't match the empty input. Since it outputs itself, it's a quine (as defined in this challenge).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), Score 1
```
=
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f9v9/AA "05AB1E – Try It Online")
`=` prints top of stack (nothing) without newline.
(empty program) also generates no output.
Boring solution, but it works.
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), Score 2
```
/
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/9f//9/AA "Braingolf – Try It Online")
Niladic `/` pushes `5`, with implicit output, `5` also pushes `5`.
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), Score 2
```
T
```
**Output:** `0` ([Test it](http://ethproductions.github.io/japt/?v=1.4.5&code=VA==&input=))
---
```
0
```
**Output:** `0` ([Test it](http://ethproductions.github.io/japt/?v=1.4.5&code=MA==&input=))
---
Any uppercase letter after `T` would also work in the same way.
] |
[Question]
[
Dr. Trump is the head psychiatrist at a mental hospital, which is populated by murdering psychopaths. If 2 psychopaths are left together, they will end up brutally injuring or even killing each other, so Dr. Trump needs to build walls to separate these psychopaths, but owing to the limited amount of funds he has left, he has to minimise the number of walls he builds. Walls of a room can either be horizontal or vertical in nature and of any length.
Help Dr. Trump minimise the number of walls he builds to separate all the psychopaths in a 2\*n psych ward.
Also, do keep in mind that the shortest code wins.
## Input
The first 2 lines contains the position of psychopaths (denoted by '#') and empty spaces (denoted by '-').
## Output
An integer which is equal to the minimum number of walls to build to separate all the psychopaths from each other.
## Input Constraints
1 <= n <= 1000000
# Sample Test Cases
## Test Case 1
Sample Input
```
##########
##########
```
Sample Output
```
10
```
## Test Case 2
Sample Input
```
#-#-#
-#-#-
```
Sample Output
```
3
```
## Test Case 3
Sample Input
```
#-----
------
```
Sample Output
```
0
```
[Answer]
## Python, 270 228 166 156 bytes
```
a=input();b=input();m=lambda s:[c=="#"for c in s];f=m(a);g=m(b);s=p=0
for i in range(len(a)):q=2*f[i]+g[i];r=p&q;s+=r!=0;p=r or p|q
print(s+(any(f)&any(g)))
```
PEP8-ified:
```
a = input()
b = input()
m = lambda s: [c == "#"for c in s]
f = m(a)
g = m(b)
s = p = 0
for i in range(len(a)):
q = 2*f[i]+g[i]
r = p & q
s += r != 0
p = r or p | q
print(s+(any(f) & any(g)))
```
[Try it online!](https://tio.run/##PYu9DoMwEIN3nuKaSChXFtRuRPckiCFQkkaCkB86IPXd02SpB9vSZ/vrfB/umbMi6/znFCjnf9tpU/v8UpCGcSFinOkjwgLWQZqkpl0olKbEjDKRp76p3FYelTOr2FZXJjgEetz1aKfOFJORfBtk6ijeqJeeIpSX/4bGR@tOkTqh3CU0tjUMIubMeBVrGAcAzn4 "Python 3 – Try It Online")
This is my first time here, be gentle please ;)
There is always a horizontal wall in the middle, except when prisoners are only on one side -- the addition in `print()` takes this into account. Strategy here is to break horizontal bar into sections such that there is no more than one prisoner on each side, for each section.
The `for` loop uses an int, p, to hold two bit flags, indicating whether the current top/bottom section already contains a psychopath. We `&` this with the flags from the new gridsquare to check whether we are going to overflow, and need to place a wall; if so, we increment s. We also use `p&q` to decide how to update the state: if we overflow, we hold onto just the overflowed prisoner (`p&q`). Otherwise, we `|` the new prisoners onto our current prisoner state. Using `and` and `or` as a ternary operator again here.
There are some helper functions at the top, as well as throwaway variable names for values used more than once.
Edit:
It seems like this got simpler as it got shorter. It used to use all kinds of wacky behaviour
] |
[Question]
[
**This question already has answers here**:
[Ordering a list](/questions/85835/ordering-a-list)
(29 answers)
Closed 6 years ago.
**Task**
Basically you have an array of random integers e.g.
```
I() = [1, 4, 3, 2, 5, 3, 2, 1]
```
and you have to create another array of the same length with the numbers 1 to the size of the array in place of the smallest to largest numbers respectively, e.g.
```
O() = [1, 7, 5, 3, 8, 6, 4, 2]
```
For duplicates, the first occurrence is taken as the smaller of the indices.
**Test Cases:**
```
Input: I() = [1, 5, 3, 4, 5, 3, 2, 4]
Output: O() = [1, 7, 3, 5, 8, 4, 2, 6]
Input: I() = [1, 5, 3, 2, 5, 3, 2, 4, 6, 6, 5]
Output: O() = [1, 7, 4, 2, 8, 5, 3, 6, 10, 11, 9]
```
**Rules**
1. It should work with array of any finite length
2. All integers are positive(greater than 0)
3. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the least amount of bytes wins!
[Answer]
# [Haskell](https://www.haskell.org/), 41 bytes
```
f l|z<-zip l[0..]=[sum[1|q<-z,p>=q]|p<-z]
```
[Try it online!](https://tio.run/nexus/haskell#@5@mkFNTZaNblVmgkBNtoKcXaxtdXJobbVhTCBTUKbCzLYytKQAyY//nJmbmKdgqFBRl5pUoqCikKUQb6iiY6igY6ygYITFMdBTMwMg09j8A "Haskell – TIO Nexus")
Haskell doesn't have build-in sorting, so we have to roll up our sleeves. We pair each element with its index with `z<-zip l[0..]`, then for each pair counts the number of pairs that are smaller or equal. This first compares the values, then tiebreaks by their index.
[Answer]
# Bash + coreutils, 28
```
f()(nl|sort -k2)
f|f|cut -f1
```
[Try it online](https://tio.run/nexus/bash#@5@moamRl1NTnF9UoqCbbaTJlVaTVpNcCuSkGf7/b8hlwmXMZcRlCiYNAQ).
[Answer]
# Dyalog APL, 2 bytes
[`⍋⍋`](http://tryapl.org/?a=%u234B%u234B1%204%203%202%205%203%202%201&run)
`⍋` is the symbol for [grade up](http://help.dyalog.com/15.0/Content/Language/Primitive%20Functions/Grade%20Up%20Monadic.htm) - return a permutation that sorts the argument. Applied twice, it does what's asked for in this problem. Indices in Dyalog are 1-based by default.
[Answer]
# JavaScript (ES6), 96 bytes
```
f=(a,b=a.length,c=[...Array(b)])=>(m=a.lastIndexOf(Math.max(...a)),a[m]=0,c[m]=b--,m?f(a,b,c):c)
```
```
f=(a,b=a.length,c=[...Array(b)])=>(m=a.lastIndexOf(Math.max(...a)),a[m]=0,c[m]=b--,m?f(a,b,c):c)
console.log(f([1, 5, 3, 4, 5, 3, 2, 4]));
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 35 bytes
```
->a{a.zip(1..999).sort.map{|x,y|y}}
```
[Try it online!](https://tio.run/nexus/ruby#S7P9r2uXWJ2oV5VZoGGop2dpaampV5xfVKKXm1hQXVOhU1lTWVv7v0AhLTraUMdUx1jHBEwa6ZjExv4HAA "Ruby – TIO Nexus")
] |
[Question]
[
# Introduction
It was just a normal day, here at your military base. Suddenly, you looked up to see a bomb falling down from the sky! You need to create a program to predict where it will fall, and tell you the location.
# Challenge
You will be given a bomb in the form of `Start-X Start-Y X-velocity Y-velocity`. You can assume that they will all be positive integers. 0 is a valid input only for `Start-x` and `Start-y`. The bomb starts with x `Start-x`, and y `Start-y`. Each "frame" (no graphical output required), the bomb will move `x-velocity` units right, then `y-velocity` units down. Continue doing this until the bomb reaches y of 0 or below. Then, output what it's x was when it hit the ground.
# Test Cases
1
Input:`0 10 2 2`
Output:`10`
2
Input:`5 4 3 2`
Output:`11`
3
Input:`11,8,7,3`
Output:`32`
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins!
[Answer]
# 05AB1E, 9 bytes
```
¹³²(I÷(*+
```
[Try online](https://tio.run/nexus/05ab1e#@39o56HNhzZpeB7erqGl/f@/KZcJlzGXEQA)
[Answer]
# TI-Basic, 21 bytes
```
Input :Prompt A,B:X+A+Aint(Y/B-E~9
```
If the ceiling function did not have to be implemented, it would be more straightforward at 13 bytes:
```
Input :Prompt A,B:X+AY/B
```
[Answer]
# Python, ~~45~~ 28 Bytes
```
lambda a,b,x,y:a+x*-(-b//y)
```
[Try it online!](https://repl.it/GuwM/1)
[Answer]
# Scheme ~~40~~ 36 Bytes
```
λ(x y u v)(+ x(* u(ceiling(/ y v))))
```
[Answer]
# Haskell, 21 bytes
```
(a#b)x y=a-x*div(-b)y
```
The trivial answer: defines an operator that takes 4 arguments and then uses the formula.
Could probably be golfed more.
EDIT: Yep, Ørjan Johansen points out we can use `a-x*div b(-y)`, which brings us to 22 bytes. [Try it online!](https://tio.run/nexus/haskell#@6@RqJykWaFQaZuoW6GVklmmkKShW6n5PzcxM882JV@hoCgzr0RBRUHDQNnQQNNIwYhLAQrgMqbKJprG2CQMDZUtNM0VjP8DAA "Haskell – TIO Nexus")
At this point, the code is really more other people than mine, so I'm going to mark this answer community wiki. Feel free to golf this further if you want :)
[Answer]
# JavaScript, ~~29~~ 28 bytes
Thanks @user5090812 for golfing off 1 byte
```
(a,b,x,y)=>a+x*((b+y-1)/y|0)
```
[Try it online!](https://tio.run/nexus/javascript-node#S7P9r5Gok6RToVOpaWuXqF2h5ZtYkqGXnJqZo5GkX6n5Pzk/rzg/J1UvJz9dI03DQMfQQMdIx0RT8z8A "JavaScript (Node.js) – TIO Nexus")
If it did not have to move x then y but was instead falling in a straight line it would be 18 bytes
```
(a,b,x,y)=>a+x*b/y
```
[Answer]
# C#, 46 bytes
```
(a,b,c,d)=>a+c*(int)Math.Ceiling((double)b/d);
```
[Answer]
# Ruby, 21 bytes
```
->x,y,v,w{x-v*(y/-w)}
```
[Answer]
# Java 7, 66 bytes
```
int f(int a,int b,int x,int y){return a+x*(int)Math.ceil(1f*b/y);}
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 8 years ago.
[Improve this question](/posts/49814/edit)
I'm not even sure if this is even possible, but I think it's worth a shot.
**The Challenge**
Code/conceptualize a pseudo-random number generator that has the potential to produce results evenly spaced out with similar frequencies... with a twist. The random number generator has to 'loop' back after Foo iterations to its beginning state then produce the exact same results. *Foo is a variable of all positive integers.*
For example, if the iterations amount is 4 and the random numbers generated after 4 iterations are {93,5,80,13}, then the next 4 iterations will produce {93,5,80,13}, as will the next 4 after that and so on.
**Limitations**
1. Random numbers can't be pre-defined. For example, the algorithm can't simply iterate over {1,2,3,4,...int.MaxValue}, up to the iteration amount then go back to the first value.
2. Similar to Limitation 1, random numbers can't be cached so a set of numbers can't be generated, saved, then repeatedly returned.
3. Similar to Limitation 2, the random number generator can't be 'forced' back to a certain state. Beginning seed numbers and whatnot cannot be saved.
4. The RNG can't use the number of iterations its run.
In other words, the Generator has to arrive back at its beginning state solely through consecutive calculations.
**Objective**
Shortest code wins!
[Answer]
# J
I think the simplest solution to this would be the slightly bendy
```
p =: 0
random =: 3 : '(p =: y | >: p) } ?. y # 0'
```
That is used like this:
```
random 5
0.329284
random 5
0.335644
random 5
0.985972
random 5
0.0583756
random 5
0.038363
random 5
0.329284
```
This can be easily modified to provide integers, just change the 0 to whatever value you want as a maximum. Alternatively, one might write the following code:
```
p =: 0
random =: 4 : '(p =: y | >: p) } ?. y # x'
```
Used like this:
```
10 random 5
8
10 random 5
6
10 random 5
5
10 random 5
4
10 random 5
6
10 random 5
8
```
### How this works
>
> This uses the J primitive `?.`: the statically seeded random number generator; as opposed to `?`: the dynamically seeded random number generator. This makes sure the outcome is always the same when run with the same arguments. `p` is just a simple array pointer here, that gets incremented with every run of the function, up to a maximum of `y`: the left argument. Every time this code is executed, a list of `y` random numbers is generated (to comply with the rules). Yes, I do realize this is very much on the edge of the phrasing of the question and that it is most likely against the spirit of the question.
>
>
>
[Answer]
# Python
# Edit
Since the approach below does not satisfy the criterion, I give an even simpler method [Full Cycle](http://en.wikipedia.org/wiki/Full_cycle), which always produces a full cycle:
```
def generatePeriodic(seed, period):
x = seed
increment = findSmallestCoPrime(period)
while True:
x = (x + increment) % period
yield x
```
This method always yields all values from `[0, period - 1]` and then repeats itself. Here `findSmallestCoPrime` is a function that returns the smallest prime `p` for which `gcd(p, period) = 1` holds.
# Previous approach
```
def generate(seed):
a = 2 * 5 * 7 + 1
c = 1
m = 2 * 5 * 7 * 7
x = seed % m
while True:
yield x
x = (a * x + c) % m
```
This is a basic [Linear congruential generator](http://en.wikipedia.org/wiki/Linear_congruential_generator), with a period `m`. `m` is in this case 490.
The restrictions are:
1. `0 < m`
2. `0 < a < m`
3. `0 <= c < m`
4. `0 <= seed < m`
Linear congruential generator has full period for all seed values if and only if:
1. `c` and `m` are coprime,
2. `a - 1` is divisible by all prime factors of `m`, and
3. `a - 1` is a multiple of `4` if `m` is a multiple of `4`.
With the following, we can choose (almost) any period `m`, and modify the code accordingly. We always choose `c = 1`, to satisfy the first point. Then we factorize `m = p_1 ^ k_1 * p_2 ^ k_2 * ... * p_n ^ k_n`, and we set `a = p_1 * p_2 * ... * p_n + 1`. So we satisfy the second point. Finally, if `m % 4 == 0` we set a new value to `a = 2 * (p_1 * p_2 * ... * p_k) + 1` (here note, that `(p_1 * p_2 * ... * p_n) % 2 == 0`). With this, we satisfy the third point (and the second point is still satisfied).
The only values of `m` that can not generate a Linear congruential generator are of type: `m = 4 * p_1 * p_2 * ... p_n`, where `p_i != 2`. This is because in such cases we get `a = m + 1`, which violates the second point of restrictions.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/49718/edit).
Closed 8 years ago.
[Improve this question](/posts/49718/edit)
Write a program that calculates the first n perfect numbers. A perfect number is one where the sum of the factors is the original number. For example, 6 is a perfect number because 1+2+3=6. No non standard libraries.The standard loopholes are forbidden.
[Answer]
# CJam, 24 bytes
```
1{{2*_(mp!}g__(*2/p}ri*;
```
[Try it online.](http://cjam.aditsu.net/#code=1%7B%7B2*_(mp!%7Dg__(*2%2Fp%7Dri*%3B&input=8 "CJam interpreter")
Makes use of the [Euclid–Euler theorem](http://en.wikipedia.org/wiki/Euclid%E2%80%93Euler_theorem "Euclid–Euler theorem - Wikipedia, the free encyclopedia"):
An even number `P` is perfect iff `P = 2 ** (N - 1) * (2 ** N - 1)` where `2 ** N - 1` is prime.
### Disclaimer
If there are odd perfect numbers, this code will fail to generate them. However, there are no known odd perfect numbers.
### How it works
```
1 e# A := 1
{ }ri* e# do int(input()) times:
{ }g e# do:
2* e# A *= 2
_( e# M := A - 1
mp! e# while(prime(P))
__(2/ e# P := A * (A - 1) / 2
p e# print(P)
; e# discard(A)
```
[Answer]
# Pyth, 25 bytes
```
J1W<lYQy=JI!tPKtyJaY*JK;Y
```
Tests whether Mersenne numbers are prime. If so, it generates the corresponding perfect number. Can find the first 8 perfect numbers in under a second.
Note: Only generates even perfect numbers. However, since it has been proven that [any odd perfect number is greater than 10^1500](http://www.lirmm.fr/~ochem/opn/opn.pdf), this algorithm is correct on inputs up to 14.
[Demonstration.](https://pyth.herokuapp.com/?code=J1W%3ClYQy%3DJI!tPKtyJaY*JK%3BY&input=8&debug=0)
[Answer]
# Pyth - 27 25 bytes
Extremely super slow brute force approach.
```
K2W<ZQ~K1IqKsf!%KTr1KK~Z1
```
Trial division to factor, then while loop till length of perfect numbers is enough.
[Try it here online](http://pyth.herokuapp.com/?code=K2W%3CZQ%7EK1IqKsf!%25KTr1KK%7EZ1&input=3).
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 8 years ago.
[Improve this question](/posts/46976/edit)
There's a board with *n* squares in a horizontal row.
You start in the leftmost square, and roll a 3-faced dice.
3 possible outcomes for a single roll of the die:
1. **Left**: you move 1 step to the left, if possible.
2. **None**: you stay where you are
3. **Right**: you move 1 step to the right, if possible.
You want to roll the dice exactly *t* times, and end up at the rightmost square on the last roll.
If you arrive at the rightmost square before *t* rolls, your only valid move is **None**.
You need to determine the number of valid (meaning, for instance, that you don't count sequences that try to move left or right from the rightmost square), unique sequences of dice rolls, for given (t,n) pairs. As the answer may be large, give it modulo 1000000007 (ie. 10^9+7).
* t is a positive integer s.t. t <= 1000
* n is a positive integer s.t. 2 <= n <= 1000
Sample testcases:
* t=1, n=2, answer=1
* t=3, n=2, answer=3
* t=4, n=3, answer=7
The shortest code in bytes wins.
[Answer]
# Python, 74
```
f=lambda t,n,i=1:i==n or t*i and sum(f(t-1,n,i+d)for d in[-1,0,1])%(1e9+7)
```
A recusive solution. The current position `i` is stored 1-indexed as an optional argument.
* If the current position `i==n`, we've arrived at the final square and are forced to stay still, giving 1 path.
* Otherwise,
+ If the remaining time `t==0`, we've run out of time, so there's 0 paths.
+ If the current position `i==0`, we've run off the left end already, so there's 0 paths.
* If neither of those was true, there we recurse. We add up the path counts for each of the directions left, none, and right, corresponding to displacements `[-1,0,1]`, and take the result modulo `1e9+7` as required.
An alternative solution that uses `eval` with string substitution to do the sum. Same number of chars. Note the use of unary `+` to start the sum.
```
f=lambda t,n,i=1:i==n or t*i and eval(3*'+f(t-1,n,i+%d)'%(-1,0,1))%(1e9+7)
```
---
Here's another a solution that is surely short for any language with built-in matrices, so anyone who can golf it is welcome to take it.
Let `M` be the `n*n` transition matrix for the walk, which is a tridiagonal banded matrix with 1's on the main diagonal and the diagonals above and below it, except for a 0 for movement left from the rightmost cell.
```
1 1 0 0 0
1 1 1 0 0
0 1 1 1 0
0 0 1 1 1
0 0 0 0 1
```
Then, the output is `(1,n)` entry of the matrix power `M^t`.
] |
[Question]
[
>
> Noel Constant did it without genius and without spies.
>
>
> His system was so idiotically simple that some people can't understand it, no
> matter how often is is explained. The people who can't understand it are people
> who have to believe, for their own peace of mind, that tremendous wealth can be
> produced only by thremendous cleverness.
>
>
> This was Noel Constant's system:
>
>
> He took the Gideon Bible that was in his room, and he started with the first
> sentence in Genesis.
>
>
> The first sentence in Genesis, as some people may know, is: "In the beginning
> God created the heaven and the earth." Noel Constant wrote the sentence in
> capital letters, put periods between the letters, divided the letters into
> pairs, rendering the sentence as follows: "I.N., T.H., E.B., E.G., I.N. N.I.,
> N.G., G.O., D.C., R.E., A.T., E.D., T.H., E.H., E.A., V.E., N.A., N.D., T.H.,
> E.E., A.R., T.H."
>
>
> And then he looked for corporations with those initials, and bought shares in
> them. His rule at the beginning was that he would own shares in only one
> corporation at a time, would invest his whole nest-egg in it, and would sell the
> instant the value of his shares had doubled.
>
>
>
–Kurt Vonnegut, *Sirens of Titan*
The investor Noel Constant is getting tired of using his system manually. He
needs the power of computers to pick the companies to invest in.
Noel Constant is willing to learn how to execute a command line script or a
function in the language of your choice. He will provide a single string of
input. He won't bother removing any whitespace, punctuation, or change case for the input string. He doesn't like that kind of work.
In return he expects to see a list of companies he can invest in, produced
according to his idiotically simple system. He wants to see each company on its
own line with the initials in brackets. If there isn't a company with the
initials needed he wants to see three dots (`...`).
```
International Nitrate (IN)
Throwbridge Helicopter (TH)
Electra Bakeries (EB)
Eternity Granite (EG)
... (IN)
```
His company, Magnum Opus, provided a list of company names and their initials
for you: <https://gist.github.com/britishtea/2f57710a114cfd79616d>.
As you may have guessed, Noel Constant doesn't like reading, so he'll want the
shortest program or function possible.
### EDIT
To clarify, the input to the function or program is *string* (*with* punctuation and whitespace, case unaltered). An example of such a string is "In the beginning
God created the heaven and the earth." The list of company names and initials *is not* an input source, it should be read some other way (from disk for example).
The output is a list in the above format. I forgot to mention in the original challenge that the order the company names appear in shouldn't be altered, i.e. if you read the initials in the output from top to bottom it renders the original input (stripped of punctuation and whitespace).
**This is no longer a requirement**, but if your function or program satisfies this condition, there is a `0.9` bonus (`# characters * 0.9`) in it for you.
[Answer]
**Unix tools, 111 \* 0.9**
(Not counting downloading and parsing the Bible)
```
$ curl -s https://www.gutenberg.org/cache/epub/10/pg10.txt|grep '^[0-9]:'|cut -d' ' -f2-|sed 's/[^a-z]//gi'|tr -d \\n|fold -w2|xargs -n1 sh -c 'grep -i ^$0 symbols.txt'|sed -r 's/(..) (.*)/\2 \(\1\)/'
Zylog Systems Ltd (IN)
Zynga Inc - Cl A (TH)
Zwahlen & Mayr Sa-br (EB)
Surpapelcorp Sa (EG)
Zylog Systems Ltd (IN)
Nisource Inc. (NI)
Novagold Resources Inc. (NG)
Zealand Pharma A/s (DC)
Everest Re Group, Ltd. (RE)
Atlantic Power Corporation (AT)
^C
```
I am not a professional investor but I think that the more times a company is mentioned in the Bible the more successful it will be, so I would invest in these:
```
10027 th - Zynga Inc - Cl A
9026 he - Hawaiian Electric Industries, Inc.
4748 nd - *
3681 an - Autonation, Inc.
3150 ha - Hawaiian Holdings, Inc.
3109 er - *
2925 re - Everest Re Group, Ltd.
2829 in - Zylog Systems Ltd
2665 nt - *
2519 es - *
```
(Future founders, consider creating a company with stock symbols I marked with `*`, they are not yet taken)
[Answer]
# Mathematica, 186
```
Grid[{If[Length[a=FinancialData[#,"Lookup"]]>0,FinancialData[a[[1]],"Company"],"..."],#}&/@StringJoin/@Partition[Select[Characters[ToUpperCase@#],IntersectingQ[{#},CharacterRange["A","Z"]]&],2]]&
```
The output looks like this:
This actually doesn't quite work, but I think it's pretty neat that Mathematica can do this. For some reason, though, it has trouble finding its own stocks. For example, it finds "NYSE:IN" but then says it's not a known entity:
Still, that's about as far as I think I'll go with it, unless someone knows why it's confused about the NYSE stocks. Feel free to expand or golf.
[Answer]
# Python 3, 174 \* 0.9 = 156.6 bytes
Rereading the rules, the company names can be in a file. This works with a file named `w` (No file extension) in the same format as the github.gist in the question. Takes input via stdin and outputs in the format `company name (SC)` or `... (SC)` where `SC` is the stock code.
```
a={l[:2]:l[3:-1]for l in open("w").readlines()}
s="".join(c.upper()for c in input()if c.isalpha())
for i in(s[c:c+2]for c in range(0,len(s),2)):print(a.get(i,"..."),"(%s)"%i)
```
### Old version, ~~248~~ ~~241~~ 238 \* 0.9 = 214.2 bytes
This is the same as above, except it gets the stock codes from the internet.
```
from urllib.request import*
a={l[:2]:l[3:]for l in urlopen("http://goo.gl/lZVoIE").read().decode().split("\n")}
s="".join(c.upper()for c in input()if c.isalpha())
for i in(s[c:c+2]for c in range(0,len(s),2)):print(a.get(i,"..."),"(%s)"%i)
```
The `goo.gl` link is the link to the gist shortened.
] |
[Question]
[
It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, [visit the help center](/help/reopen-questions).
Closed 11 years ago.
### Task
Develop some code to generate a psuedo-random number between X and Y (taken as input). Explain why or how it works.
### Conditions
* Do not use any random generating seeds, pre-written randoms, or external source to generate the random number.
* Make something as close to random as you can get. No hard coding of values.
Whoever gets the most upvotes for a new, innovative, out of the box, idea, wins.
[Answer]
## C
not sure if the `volatile` keyword is needed (or what other OS dependencies are assumed here)
simply takes the address of a variable, and maps it to [min, max]:
```
int rand(int min, int max)
{
volatile int order = max - min + 1;
return min + (int)&order % order;
}
```
[Answer]
# Mathematica
**Rationale**
Pi is an irrational number. It decimal representation does not repeat.
I strongly suspect that it does not "favor" any of the base ten digits, 0...9, nor any numbers of length when one partitions the decimal into strings of d digits. This suspicion can later be informally checked using the code below.
**Code**
The following will select integers between the integers x and y, where x is less than y.
y need not have the same number digits as x. The routine will begin at the cth digit of Pi. At the end of the procedure, the counter will be at c + n.
```
ClearAll[f]
f[x_,y_,c_,n_]:=
Module[{diff=y-x,d},
d=Length[IntegerDigits[diff]];
Cases[FromDigits/@Most[IntegerDigits[Round[N[Pi,c+n+1]10^(c+n-1)]]][[c;;c+n1]]~Partition~d,
i_/; i>x-1 && i<y+1]]
```
Suppose we want to generate a large (> 3000000), pseudo-random list of integers between 7 and
78. Here is how to request it. I've estimated that we'll need to use about 10^7 digits of Pi. We'll begin from position 1, that is, c=1.
```
(results= f[7,78,1, 10^7])//Timing
```
Note how the unsorted and untallied results maintain the order of Pi's digits: 314159...
Note also that the result took just under 20 seconds. As we move further along, we'll encounter practical limits to how much we can process in a reasonable amount of time. But since this is merely an exercise in thinking out of the box, we'll ignore this limitation as we proceed.
**Examining the results**
When we tally and plot the results we see that Pi does not particularly favor any numbers in this range:
```
SortBy[Tally[results],First]
```
Notice that the integers between 7 and 78 were chosen more or less with equanimity. Further tests would show this holds up.
```
ListPlot[%]
```
Similar checks should show whether or not Pi plays favorites with any numbers at all, regardless of how many digits it holds. [I checked for 1, 2, and 3 digit numbers over tens of millions of draws and found no bias starting from the beginning of Pi. A rigorous check would require more systematic examination or theoretical insights.]
[Answer]
# Perl
First, here is a solution that was golfed, coming in at 30 characters:
```
$a=<>;$b=<>;print$$%($b-$a)+$a
```
This solution uses the process number of the program as the random seed, similar to using the location of the variables as a seed. It works the best when the min and max are small compared to the process number.
Here is a version that uses command line arguments, with 36 chars:
```
print$$%($ARGV[1]-$ARGV[0])+$ARGV[0]
```
And here is a version as a subroutine that returns the random value (without printing to screen), with 29 chars:
```
sub a{$$%($_[1]-$_[0])+$_[0]}
```
Second, I am working on a solution that adheres to the strictest reading of the spec, which is that the program cannot be influenced by anything except the two arguments.
[Answer]
## Python
```
import sha
R=lambda x,y:x+int(sha.new('%d_%d'%(x,y)).hexdigest(),16)%(y-x)
```
[Answer]
# JavaScript
```
function getRandom(x,y) {
s=document.createElement("SCRIPT");
s.src="http://search.twitter.com/search.json?q=%22random%22&&callback=t"
document.getElementsByTagName("HEAD")[0].appendChild(s);
var c = 0;
window.t=function (d) {
g=d.results;
for(z=0; z<g.length; z++) {
c+=g[z].id/0xfff;
}
console.log(x+c%(y-x))
};
}
```
This is pretty disgusting really. Queries Twitter, via the JASONP API, for recent tweets containing the word "random", then it uses the ID's of each of the returned tweets to calculate the "random" number.
You might want to wait a few seconds in between each call of the function, also it doesn't return a value, it just outputs one to the console. (Told you it was disgusting).
[You can try it here.](http://jsfiddle.net/Aj9Cy/1/)
[Answer]
## Python 2.x, 454
```
z=lambda n,b:int("0b"+(bin(n)[2:][:-b]or'0'),2)
r=range
g=624
def m(s,t):
a=[s]
for i in r(1,g): a+=[1812433253*((a[i-1]^(a[i-1]>>30))+i)]
for i in r(t):
i%=g
if not i:
q=0
for c,d in zip(a,a[1:]+[a[0]]):
u=(z(c,1)+z(d%g,31))
a[q]=a[(q+397)%g]^(u>>1)
if u%2:a[q]^=2567483615
q+=1
y=a[i]^(a[i]>>11)
y^=(y<<7&2636928640)
y^=(y<<15&4022730752)
y^=(y>>18)
yield y
```
Mersenne twister algorithm. It can probably be golfed some more.
Usage:
```
>>> list(m(s, t))
```
Where `s` is the seed, and `t` is the number of numbers to generate.
[Answer]
# Python, 32
Similar to ardnew's answer:
```
a,b=input()
print a+id(1)%(b-a)
```
] |
[Question]
[
**Description:**
Write the fastest comparison function for an opaque field containing a double. Here is my example:
```
// Three-way comparison function:
// if a < b: negative result
// if a > b: positive result
// else: zero result
inline int Compare(const unsigned char* a, const unsigned char* b) const
{
if (*(double*)a < *(double*)b) return -1;
if (*(double*)a > *(double*)b) return +1;
return 0;
}
```
Size: 188 characters (excluding the comments)
Speed: N/A
**Background:**
[Google's LevelDB](http://leveldb.googlecode.com/svn/trunk/doc/index.html) stores keys as opaque fields (i.e. bytes) and it requires the use of a comparator when the keys cannot be compared as bytes, such as the case with doubles. [You can read this article to see why Floating-Point binary comparison is tricky](http://kipirvine.com/asm/workbook/floating_tut.htm), so when LevelDB stores key-value pairs on disk it has to properly compare the opaque keys in order to achieve good data locality.
**Correct Submission:**
1. The submission must be written in C/C++.
2. The submission must correctly compare the opaque fields as doubles.
3. Given that 1 and 2 are satisfied, the winner should be selected based on the minimum CPU operations ticks (i.e. the fastest comparison).
If there is a tie, then the shortest correct submission will be awarded.
P.S. This is my first time posting, so please let me know if I should correct/improve something in the competition.
[Answer]
This function is written in MMIX assembly. It should perform the calculation in 2υ
+ 5μ. If you inline it, the call is no longer needed so you can save the `POP` instruction. This function should be compatible with gcc for MMIX. (Read TAOCP vol 1. fasc 1 for more information):
```
compareDoubles IS @ ; Declare symbol, @ is the current position
LDOU $0,$0,0 ; Load first double (LDOU: load octa unsigned), 1v
LDOU $1,$1,0 ; Load second double, 1
FCMP $0,$0,$1 ; Compare floating point values, 4µ
POP 1,0 ; return, 1µ
```
If you assemble it, the code is 16 bytes long and may looks this:
```
8f 00 00 00 8f 01 01 00 01 00 00 01 f8 01 00 00
```
[Answer]
```
#define compare(X, Y) ((X)<(Y)?-1:((X)>(Y)?1:0))
// 48 characters
```
or want to pass a pointer you can define
```
#define compare(X, Y) (*((double*)X)<*((double*)Y)?-1:(*((double*)X)>*((double*)Y)?1:0))
// 88 characters
```
] |
[Question]
[
*This is the robbers thread of this cops and robbers challenge. The cops thread is [here](https://codegolf.stackexchange.com/questions/264161/hashers-and-crashers-cops)*.
[Related, but hashes numbers instead of strings and uses a different scoring system.](https://codegolf.stackexchange.com/q/51068/117478)
## Definitions
A hash collision is when two different strings produce the same hash.
## Summary
In this challenge, the cops will make a hash function, with a collision they know of. Then, the robbers will try to crack it by finding a hash collision in the cop's hash algorithm. To crack an answer, the hash collision the robber finds does not have to be the intended solution.
If a cop submission is not cracked for 7 days, it is safe, so mark it as such and reveal the intended crack and the score.
If a cop submission is cracked, mark it as such and edit in a link to the crack.
## Format
A robber answer has to contain **the hash collision, a link to the cracked answer, and the score**.
## Scoring
The score of a robber answer is **the sum of the number of bytes of the two strings with the hash collision, with the *higher* score being better**.
## The winner
With robbers and cops being ranked separately, the winner is the person with the best scoring answer.
## Example
Cop:
>
> ### Python
>
>
>
> ```
> from hashlib import*
> def singlecharhash(x):
> a = blake2b(digest_size=1)
> a.update(x)
> return a.hexdigest()
>
> ```
>
>
Robber:
>
> ### 4 Points, Cracks cop's answer
>
>
> `¯` and `É`, both 2 bytes.
>
>
>
## Pinboard
I am thinking of changing the scoring system to make it the minimum of the two strings. Any thoughts?
[Answer]
# [Cracks Sisyphus's](https://codegolf.stackexchange.com/a/264180/73054), 1 byte
`b''` and `b'\x00'`
[Try it online!](https://tio.run/##bY7RCsIwDEXf@xXxqSsMmRNFhP2JIN0W1zHXljaD9etrV1AQzVM4uSeJDaSMPl6si3GcrXEEapYdYz0@YA53Jb0qVnFlkEp6jylAwWJi0DTQBkKfZw5pcTrL@34c0FOxltDywZgenks38RK4V7I@nbmIE4YDJJ1zlto6t7e1qjizbtRUvC9vOSF@Yf2BedOugQz/2dub32Z8AQ "Python 3.8 (pre-release) – Try It Online")
I'm not sure if this is the intended solution but it's definitely the simplest.
As @gsitcia has pointed out in the comments, for SHA-256 if the key is less than 64 bytes HMAC pads it with null bytes to length 64. So by adding a null byte to any key with less than 64 bytes we get the same result.
As @gsitcia also points out, for any key longer than 64 bytes, it is replaced with its hash. We can see this in action [here](https://tio.run/##pZDBasMwDIbvfgrv5HiU0mRdkxZy6BP0sKvHsBO1zrokxnZBfvpMNWwwttt0ENYvfT@yXIp2np4a55dlGN3sI7ej7hjr4czH9GZ1sAXKA@MUOgSggZgckMbblpsUIeSeh3jzU4bX/XCBEAtccSMu89zzj1t3FSsugtXV807ItQUs5HKFVHIyEfq/IRh5Vdmre9EKu63Cxig0e4VAtSmPCvcNFfWkUNNDU7c@Kyz10b6@K@x3jyTSeLkdN5T7E6WaAKOIgI1gzg9TLL5uct9dyt9i9S3m3z20PIt/0fcD/iSXTw). It is trivial to generate arbitrarily long collisions in this way.
] |
[Question]
[
**This question already has answers here**:
[Spell out the Revu'a](/questions/68901/spell-out-the-revua)
(34 answers)
Closed 7 years ago.
Your program must take in a string like:
```
test string
```
And must output each character adding one at a time like this:
```
t
te
tes
test
test
test s
test st
test str
test stri
test strin
test string
```
notice how spaces count!
Good luck!
Least Bytes win.
~N
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 3 bytes
Uses [CP-1252](http://www.cp1252.com) encoding.
```
.p»
```
[Try it online!](http://05ab1e.tryitonline.net/#code=LnDCuw&input=dGVzdCBzdHJpbmc)
**Explanation**
```
# implicit input
.p # list of prefixes
» # join by newlines
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), 6 bytes
```
"GX@:)
```
[Try it online!](http://matl.tryitonline.net/#code=IkdYQDop&input=J3Rlc3Qgc3RyaW5nJw)
```
% Implicit input
" % For each
G % Push input again
X@: % Push [1 2 ... k] where k is iteration index
) % Use as index into the string
% End for each
% Implicit display
```
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 5 bytes
```
@[@w\
```
[Try it online!](http://brachylog.tryitonline.net/#code=QFtAd1w&input=InRlc3Qgc3RyaW5nIg)
Assuming that a trailing new line is acceptable
### Explanation
```
@[ Take a prefix of the Input
@w Write it to STDOUT followed by a linebreak
\ False: try another prefix of the input
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 3 bytes
```
j._
```
[Try it here](http://pyth.herokuapp.com/?code=j._&input=%27test+string%27&debug=0).
```
j Join by newlines
._ all prefixes of implicit input
```
] |
[Question]
[
*Note: This challenge has been changed to eliminate the strict whitespace manipulation requirements that made this challenge low-quality. Some rules regarding whitespace have been changed.*
---
I'm rather good at mental math, particularly adding positive integers in my head. Here is my method for adding the numbers together (`n` is a positive integer):
* Arrange the numbers in a horizontal row
* Reorder the numbers so the `2n-1`th number in the sequence is the `n`th smallest number in the sequence and the `2n`th number in the sequence is the `n`th largest number in the sequence.
* Add the `2n-1`th number to the `2n`th number. Print the results of these additions on the next line.
* Repeat the previous step until a final result is obtained.
Your challenge is to write a program or function that prints each of the above steps until the sum of all the inputted numbers is reached. The final result must be separated from the adding steps by an additional blank newline. You may assume that all numbers inputted are unique so as to avoid confusion with the second step (and that the input is not empty). Numbers can be inputted in any format. Numbers in rows should be separated from each other by one space.
**Test cases**
For each of these, the input and output start a newline after their labels.
*Case 1*
```
Input:
314 495 767 214 141
Output:
141 767 214 495 314 //Reordering the input
908 709 314 //Adding
1617 314
1931 //Final result
```
*Case 2*
```
Input:
884
Output:
884 //Reordering the input
884 //Final result
```
Note that there is no adding step here because the reordering of the input produces the final result.
*Case 3*
```
Input:
5033 7825 2167 6374 5050 5389 3915 7231 3025 1954 7249 5143 7567 9857 462 3504 6165 6681 6361 6367
Output:
462 9857 1954 7825 2167 7567 3025 7249 3504 7231 3915 6681 5033 6374 5050 6367 5143 6361 5389 6165
10319 9779 9734 10274 10735 10596 11407 11417 11504 11554
20098 20008 21331 22824 23058
40106 44155 23058
84261 23058
107769
```
---
This is code golf. Standard rules apply. Answer with the fewest bytes wins.
[Answer]
# Ruby, ~~148~~ ~~144~~ 142 bytes
```
f=->a{a.sort!
(a.size/2).times{a[~-$.+=2,0]=a.pop}
a*=" "
puts$`+$&+$'while a.gsub!(/\d+\s+\d+/){"#{eval$&.split*?+}".ljust$&.size}
puts'',a}
```
So disappointingly long... To run:
```
f[ [314,495,767,214,141] ]
```
Prints:
```
141 767 214 495 314
908 709 314
1617 314
1931
```
] |
[Question]
[
This is the same question as [Solve the CodeSprint4 Leibniz code golf challenge in Python in 66 characters](https://codegolf.stackexchange.com/questions/10716/solve-the-codesprint4-leibniz-code-golf-challenge-in-python-in-66-characters). The variation is that I'm a C programmer. My code for the above question is:
```
#include <math.h>
main(){
int i,t,p;
scanf("%d",&t);
while(t--)
{
double s=1;
scanf("%d",&p);
for(i=1;i<p;++i)
s+=pow(-1,i)/(2*i+1);
printf("%.12lf\n",s);
}
}
```
Now I just need to know the places where I could reduce my code length.
[Answer]
1. Do everything in one line.
2. Don't read number of test cases, scanf will return -1 on EOF
3. Don't include anything, `pow(-1,i)` can be replaced by `1-i%2*2`
4. Do the sum loop in reverse to save a variable.
Here is my 102 bytes code
```
main(n){gets(&n);for(double s;s=scanf("%d",&n)>0;printf("%.15f\n",s))while(--n)s+=(1-n%2*2)/(1.+2*n);}
```
[Answer]
Remove include and replace pow by check.
Use the fact that scanf returns number of read and saved fields.
Replace while via for.
Remove figure brackets.
Use %f in printf for double - only scanf needs %lf.
I didn't check if following code works fine, but even if smth is wrong, the correct result have to be somewhere near it:
```
main(){
int i,t,p;
double s;
for(scanf("%d",&t);t--;printf("%.12f\n",s))
for(s=i=scanf("%d",&p);i<p;++i)
s+=(i&1?-1:1)/(2.*i+1);
}
```
By the way, what about making all variables double instead of int?
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/22087/edit).
Closed 9 years ago.
[Improve this question](/posts/22087/edit)
It's geeky to see a Boolean Matrix animation, but a live one would be better. Echoing only `1`s and `0`s create a program that creates an infinite loop of integer matrix.
* `1`s and `0`s are randomly echoed like an error.
* 
[Answer]
Like this?
# PHP, ~~28~~ 22
```
for(;;)echo rand(0,1);
```
---
For a better view:
```
<div style="width:800px;margin:0 auto;background-color:black;color:green;">
<?php for(;;)echo rand(0,1); ?>
</div>
```
[Answer]
### Delphi XE3 (30 28)
```
while 0<1do write(Random(2))
```
[Answer]
## TI-BASIC, 46
A classic, in my opinion.
```
"101010101010101":While 1:Disp Ans,"0"+Ans:End
```
[Answer]
## Perl, 24
```
print-+-(rand>.5)while+1
```
[Answer]
**C# 112** - **109 Thanks @masterX244**
```
using System;namespace N{class P{static void Main(string[]a){for(;;)Console.Write(new Random().Next(0,2));}}}
```
Without namespace, class name...
**45**
```
for(;;)Console.Write(new Random().Next(0,2));
```
**Uncompressed**
```
using System;namespace N{class P{
static void Main(string[] a) {
for (;;)
Console.Write(new Random().Next(0, 2));
}
}
}
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/20053/edit).
Closed 2 years ago.
[Improve this question](/posts/20053/edit)
Make an animated sound waveform using any programming language your prefer, the squares of the spectrum can be of a single color (no rainbow effect).
The animation must be infinite and not a loop sequence (must be a random animation).
You can use any kind of external library you prefer.
This is a code-golf so the shortest code will win.
Example of waveform:
(a screenshot of the result is appreciated)
Edit:
I thought was obvious,but the waveform must be horizontal.
[Answer]
## APL (61)
```
{∇n⊣⎕DL.1⊣⎕SM←1 1,⍨⊂' '⍪⊖⍉↑⍴∘'▇'¨,0,⍪n←24⌊0⌈⍵+3-?5/⍨⍴⍵}?24/40
```
It starts with random-sized bars, and changes the height of each of the bars by a random number between -2 and 2 each frame.
Screenshot:
[Answer]
# Ruby 96
The program takes two arguments which are the height and width of the "graphics", so to make it fill a 80x24 terminal, run it with `ruby spectrum.rb 80 24`
```
w,h=$*.map &:to_i
loop{o=(1..w).map{rand h}
h.times{|i|puts o.map{|j|j>i ?" ":?#}*''}
sleep 0.1}
```
Displays something like this in the terminal:
```
#
#
### #
# ### #
## ### ##
## #### ##
######## ##
######### ## #
######### ## ##
######### ## ##
######### ## #####
############# #####
############# #####
####################
```
# Ruby 22
With horizontal bars and fixed width (heigh = height of terminal)
```
loop{puts ?#*rand(24)}
```
[Answer]
# Bash and Linux utils, 79
The question specifications are a little imprecise, so here is my vertically-scrolling ascii-art interpretation that uses real sound input samples (much more interesting than random data)
```
arecord -q|xxd -g1 -c1|while read _ s _;do printf "%$[0x$s-88]s
"|tr " " =;done
```
Output for a few milliseconds of Rachmaninov's Piano Concerto #2:
```
=========================================
======================================
=======================================
===========================================
========================================
======================================
========================================
=========================================
========================================
======================================
========================================
==========================================
========================================
======================================
=========================================
=========================================
```
[Answer]
## Batch - 193
```
@echo off&setLocal enableDelayedExpansion
:s
set/ar=%RANDOM%*17/32768+4&for /l %%a in (20,-1,1)do (if %%a GEQ %r% (set l%%a= !l%%a!) else set l%%a=Û!l%%a!)&echo !l%%a!
ping 1>nul&cls&@goto s
```
Un-golfed -
```
@echo off
setLocal enableDelayedExpansion
:s
set /a r=%RANDOM%*17/32768+4
for /l %%a in (20,-1,1) do (
if %%a GEQ %r% (set l%%a= !l%%a!) else set l%%a=Û!l%%a!
) & echo !l%%a!
ping 1>nul
cls
goto s
```
This will work assuming you have an infinitely wide terminal window - I'll work on the text wrapping...
Not the prettiest - but it does the trick - **295 bytes**
```
@echo off&setLocal enableDelayedExpansion
for /f "tokens=2" %%w in ('mode con^|findstr Col')do set w=%%w
:s
mode con:cols=%w% lines=20
set/ar=%RANDOM%*17/32768+4&for /l %%a in (20,-1,1)do (if %%a GEQ %r% (set l%%a= !l%%a!) else set l%%a=Û!l%%a!)&echo !l%%a!
set/aw+=1&ping 1>nul&cls&@goto s
```
[Answer]
# Mathematica 105
This animates continually, at approximately 24 frames per second, as if it were capturing sound in real-time. However, it is not processing sound at all. (That would would require considerably more code.)
```
data1@n_ := NormalDistribution[0, 1]~RandomVariate~150;
Animate[Histogram[data1@a, Axes -> False], {a, 0, Infinity}]
```
[Answer]
# Matlab (43 / 37)
```
while(1)hist(randn(100,1));pause(1/24);end
```
Inspired by the Mathematica approach, this is just a histogram of 100 random, normally distributed numbers. the plot regenerates at 1/24 second per frame (24 fps).
Shorter, Stranger version (37):
```
while(1)bar(randn(9,1));pause(.1);end
```
This version includes negative numbers, so it doesn't exactly fit the requirements.
] |
[Question]
[
**This question already has answers here**:
[Need change of 78 cents [closed]](/questions/15872/need-change-of-78-cents)
(5 answers)
Closed 10 years ago.
Challenge: given a number, calculate how many unique, order-independent ways there are to achieve a score of that number in American Football.
Let's see how few characters can be used in each of your favorite languages! The usual rules apply. Input and output in a way that is natural to your language.
Recall that the ways to score in Football are safety (2 points), field goal (3 points), touchdown (6 points), touchdown + extra point (7 points), and touchdown + 2-point conversion (8 points).
For example, given 9 as input, the program should return 4, since you could score:
* 1 touchdown + extra point and 1 safety
* 1 touchdown and 1 field goal
* 3 field goals
* 3 safeties and 1 field goal
Note that order does not matter.
[Answer]
# Mathematica - 42
```
Length@IntegerPartitions[#,∞,{2,3,6,7,8}]&
```
# Prolog - 140
Never wrote anything in Prolog before, just knew that this problem should be quite nice for it.
```
p(0,_,[]).
p(N,[H|T],O):- N>=H,p(N,T,O).
p(N,[H|S],[H|T]):- N>=H,M is N-H,p(M,[H|S],T).
f(N,C):- aggregate(count,X^p(N,[2,3,6,7,8],X),C).
?- f(9,C).
C = 4.
```
[Answer]
## Python - 146
```
t=int(input())
from itertools import*
print len([a for a in chain(*(combinations_with_replacement([2,3,6,7,8],n) for n in range(t)))if sum(a)==t])
```
] |
[Question]
[
I tried this contest: <https://www.hackerrank.com/challenges/secret-language>
Well, the score in this contest said I made 30 out of 30 points. As the score is calculated with the formula 30\*(1000-#chars)/1000 this is impossible. Here is my code:
```
import sys,string as s
b='anbycoduepfxgqhvirjzkslwmt'
a=s.letters
b+=b.upper()
t=s.translate
m=s.maketrans
for l in sys.stdin:
print{'N':t(l[7:],m(a,b)),'E':t(l[7:],m(b,a)),'O':''}[l[1]],
```
The contest is over, so asking is no cheating but I would like to get some realistic score. I have 187 chars with newline and 195 with cr-lf. For pythoncode 24.39 (assuming newline) isn't so bad, but I think it can be done better.
For completeness here is the challenge:
Bob and Fred pass notes to each other in class all the time. However their teacher started intercepting their messages and reading the messages out loud to the class. Undeterred, Bob and Fred decided to encode their messages before they pass them so that when the message is intercepted the teacher and class will not understand it.
They got together and decided on using a simple substitution cipher. The substition cipher they agreed upon is listed below:
Old Letter: ABCDEFGHIJKLMNOPQRSTUVWXYZ
New Letter: ANBYCODUEPFXGQHVIRJZKSLWMT
Using this key (Case matters!), A is changed to A, a is changed to a, B is changed to N, b is changed to n, C is changed to B, c is changed to b, … . All other characters remain the same.
However after Bob and Fred started using this method of note transfer they quickly realized that they are very slow at encoding and decoding messages. They have hired you to help them transfer messages faster by writing a program that will encode or decode messages using their substitution cipher. They want the code to be very portable so the smaller the source file is the better.
**Input**
Input will consist of several lines. Each line will begin with either the string “ENCODE”, “DECODE”, or “DONE”. If the string is “ENCODE” or “DECODE” then a message will follow. This is the message that you will have to either encode (if the first string is “ENCODE”) or decode (if the first string is “DECODE”). Messages will contain spaces and punctuation but will always be on the same line. If the string is “DONE” then this signifies that Bob and Fred are done exchanging messages.
**Output**
For each line that begins with “ENCODE” print the encoding of the message that follows.
For each line that begins with “DECODE” print the decoding of the message that follows.
Be sure to keep all capitolization and punctuation that is used in the message.
**Sample Input**
ENCODE This is a message.
DECODE Zuej ej a gcjjadc.
DONE
**Sample Output**
Zuej ej a gcjjadc.
This is a message.
**Scoring**
Your score will be 30 \* (1000 - #characters) / 1000. The minimum score a correct solution will receive is 0.03.
[Answer]
## bash and friends (168 167 chars)
```
T=ANBYCODUEPFXGQHVIRJZKSLWMT
while read x&&[ "$x" != "DONE" ]
do
[ "$x" \> "E" ]
for((z=1+$?*58;z;z--))do
x=$(tr a-zA-Z `tr A-Z a-z<<<$T`$T<<<$x)
done
echo ${x:6}
done
```
The magic number isn't so magic: it's obtained by solving a set of simultaneous modular identities obtained from the cycle structure of the permutation.
[Answer]
### GolfScript, 93 characters
```
n/{(.1=3%{;0}{(2*343+\6>1/{{..'ANBYCODUEPFXGQHVIRJZKSLWMT'.{32+}%+.@+1/\$@+@?=}%}@*n@1}if}do;
```
Example:
```
>ENCODE This is a message.
>DECODE Zuej ej a gcjjadc.
>DONE
>ENCODE This line is not processed
Zuej ej a gcjjadc.
This is a message.
```
Note: Due to the nature of i/o the input is read completely before processing and output starts.
[Answer]
## K, 95
```
d:(,/.Q`A`a)!t,_t:"ANBYCODUEPFXGQHVIRJZKSLWMT"
while[~"DONE"~f:0:0;-1@7_f^$[f like"E*";d@;d?]f]
```
Example
```
k)d:(,/.Q`A`a)!t,_t:"ANBYCODUEPFXGQHVIRJZKSLWMT"
k)while[~"DONE"~f:0:0;-1@7_f^$[f like"E*";d@;d?]f]
ENCODE This is a message.
Zuej ej a gcjjadc.
DECODE Zuej ej a gcjjadc.
This is a message.
DONE
```
[Answer]
## Python, 159
```
from string import*
n='anbycoduepfxgqhvirjzkslwmt'
r=raw_input
s=r()
while'N'>s[2]:print translate(s[7:],maketrans(*(letters,n+upper(n))[::1-2*('E'>s)]));s=r()
```
] |
[Question]
[
The same task as [Finding "sub-palindromes"](https://codegolf.stackexchange.com/questions/183/finding-sub-palindromes) but instead of finding substrings you must find **subsequences** that are **not substrings**.
eg1:
```
input: "12131331"
output:
"11", "33", "111", "121", "131", "313", "333", "1111", "1331", "11311", "13331"
or
"11", "33", "111", "333", "1111", "11311", "13331"
```
eg2:
```
input: "3333"
output:
"33", "333"
or
(null)
```
* Input is a string of printable ascii characters.
* Output is a list of *unique* strings.
* If a subsequence also appears as a substring it may be omitted.
* Shortest code wins.
[Answer]
## Haskell (119)
```
import Data.List
main=interact f
f a=show.nub.filter(\x->(not$isInfixOf a x)&&x==reverse x&&length x>1)$subsequences a
```
Isn't too difficult with a builtin `subsequences` and `nub`... :)
[Answer]
## Golfscript (95)
```
);.{{(\a\:x;.{[x]\+}%+}:b;{.!{[$]}{b}if}:a;.a{..-1%=&},\{,}{(;}/{{,}{);}/}%{+}*-.&{`}%", "*}and
```
I haven't really tried to golf this further, it's just a combination of left overs.
The question is inconsistent. My program prints all palindromic subsequences that are not substrings. Hope this is OK.
Example 1:
```
echo "12131331" | ruby golfscript.rb subseq_not_substr.gs
"11", "111", "13331", "13131", "1111", "11311"
```
Example 2:
```
echo "3333" | ruby golfscript.rb subseq_not_substr.gs
```
Empty String Example:
```
echo "" | ruby golfscript.rb subseq_not_substr.gs
```
With uglier output formatting, eg `[11 111 13331 13131 1111 11311]`, it could be made a bit shorter.
[Answer]
### GolfScript, 39 characters
```
:^1/[""]\{`{1$\+}+%}/.&{..-1%=^@?0<&},`
```
Examples:
```
> "12131331"
["11" "333" "111" "13331" "13131" "1111" "11311"]
> "3333"
[]
```
Basic blocks of the code:
```
# Save input in variable
:^
# Build all possible subsequences of the input
1/[""]\{`{1$\+}+%}/
# Filter unique ones
.&
# Filter relevant palindromes
{.
.-1%= # check if palindrome
^@?0< # check if sequence is no substring
& # and operation on both
},
# Format output
`
```
] |
[Question]
[
New Posts and New Sandbox Posts are chatbots that occupy CGSE's main chatroom, [The Nineteenth Byte](https://chat.stackexchange.com/rooms/240/the-nineteenth-byte). They've been doing their jobs for almost one full year now, so I thought I'd make a challenge to honor their contributions!
The challenge is simple: Draw the profile picture of either [New Posts](https://codegolf.stackexchange.com/users/103575/new-posts) (NP) or [New Sandbox Posts](https://codegolf.stackexchange.com/users/103625/sandbox-posts) (NSP). Your program must take as input a boolean value, and draw NP's profile picture if true and NSP's profile picture if false. (They're identical except for the color difference.)
Here are the images you need to output:
The colors of each image should be #0093E8 (NP) and #000000 (NSP). If your language is unable to output that exact shade of blue you may use the closest equivalent. The background may be white or transparent.
The image can be saved to a file or piped raw to STDOUT in any common image file format, or it can be displayed in a window.
[Answer]
## PostScript, ~~132~~ 112 + 4 bytes
```
x{0 .58 .91 setrgbcolor}if
9 9 scale 16 16 false[1 0 0 1 0 0]<~s8S_ka8b3"J.ITILd2AV!!%`RKQ2ZJ`^/O&rW<~>imagemask
```
Uses an ASCII Base-85 string to encode a 16x16 bitmap.
Takes input from command line: `gs -dx=true np-nsp.ps` or `gs -dx=false np-nsp.ps`; +4 bytes for `-dx=`. Output is displayed.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 295 bytes
*shorter version thanks to [@ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)*
```
#define p putchar(v?-1:b
*s=L"\xcd=C=C=7;104;104;10100.+6100.+6100.+6.3+3++.-.3+3++.-.3+3++.-.3+310.3+310.30.10.30B+30B+\xcf.D.0.D.0.D.0+;+1+3+;+1+3+;+1+3.8+1.0.5.1.0.5.1.C.J6I7I=1O1O1L1O1O1L.R.R.\xdf";main(b,v,n){b%=2;for(v=printf("P6 48 48 255 ");*s;v=!v)for(n=*s++-40;n--;p*232))p*0),p*147);}
```
[Try it online!](https://tio.run/##bY9PS8NAEMXvfooYEbI72WE3f4vDIlgvlYLiuZdm07U5dF2aGgriZ48bNdCDvHm/Ocy8gTHizZhxvGl3tnO7yEf@42T222My3At111zxXq/jzdm0ehlUk5LFn5WUCNUlMYccAMV/XcmZEn/4AJPDZYuPKGcDgQqhC@ICVJiVOHOJT9WqXmn1HLT@Jb4Gbc6tjemw7VzSpEPq2GdzqzOy7@EZ7Y@dO9kkfqmiYjFVVpZRzIj3NOjrgU1bTvMeQBSSnBDkeZZnjHkuWeq5KmpGX@P4DQ "C (gcc) – Try It Online")
# [C (GCC)](https://gcc.gnu.org), 318 bytes
```
#define p(x)putchar(v?255:b*x)main(b,v,n){unsigned char*s="\xcd=C=C=7;104;104;10100.+6100.+6100.+6.3+3++.-.3+3++.-.3+3++.-.3+310.3+310.30.10.30B+30B+\xcf.D.0.D.0.D.0+;+1+3+;+1+3+;+1+3.8+1.0.5.1.0.5.1.C.J6I7I=1O1O1L1O1O1L.R.R.\xdf";b%=2;for(v=printf("P6 %d %d 255 ",48,48);*s;v=!v)for(n=*s++-40;n--;p(232))p(0),p(147);}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=bZDNSsQwFIXxTWplIGnaS9J_DFFw3IwIiusBmSbN2IUxTH8oiE_iZjbzUj6NqTOFWci557uLexO45_sgX7dS7veHvtNR-XNxc6Vq3Zjas2jEtu_k22aHhts4y66rYMTvm8agKhxCgz970zZbUytv2gla4a9HqcTSqeCMpiczSoHk54SEJIRA9F9ndCaFP96Rye5nDfdAZxNOmHt0RigJc7MMZi7hIV8VK8GenB6PhBen9ai0z6uFiLn-cLcJu2tMp5H_nHsLNZU71vPDtHSFedDyQVwOeNo1ImgJiVLKTRRxi-IkxtgiikOLWFpg_nWM8ZTmnOov)
Outputs a [PPM](http://netpbm.sourceforge.net/doc/ppm.html) image. The image is run-length encoded in the variable `s`.
The boolean input is given via the number of arguments (basically corresponds to `argc % 2`).
] |
[Question]
[
# Challenge
## Premise
It's 2006, and Alice is trying to send Bob ~~their~~ her completed notes on their newly ended expeditions into the labyrinthine school library, which the two of them found suffers from a bad case of non-Euclidean geometry.1
For some reason, Alice originally created her notes, which consist of black text on a white background, using SVG. What a genius. It hits her now that Bob doesn't have a single device that will display SVG! I mean, she accidentally fried it the last time she paid him a visit at his place.
She decides to send him a black-on-white raster rendering without anti-aliasing of any sort. Of course, she's going to do it with code. Her, since it *figures* that Bob would be the sort to take to hardware rather than software.2 Regardless, Alice can't go back on her word, so she *supposes* she's got to see it through. She thinks Bob should consider himself lucky that she has so much time to spend on ~~their~~ her notes…
1. Don't get the wrong idea! She's only sending them because he asked nicely, not because she's got any sympathy for boys who play [*Quake III Arena*](https://en.wikipedia.org/wiki/Fast_inverse_square_root) for eight hours at night (or whatever it is they do) and create only the barest skeleton of notes on their own.
2. She also, mysteriously, hasn't got [a capable OS](https://en.wikipedia.org/wiki/Font_rasterization), but that's another story.
## Task
Help Alice draw rasterised glyphs. She'll re-use and position them by herself, tasks that are trivial in comparison.
Input:
* First take a string whose contents are an SVG [path](https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths) definition (`d` attribute) defining a single glyph. Only lines and cubic Béziers will be used. You only need to consider upper-case commands. Each pair of coordinates will be comma-separated. All coordinates will be given to one decimal place. Please refer to the examples.
+ There may or may not be whitespace at the top and/or left of the glyph.
* Next, take an integer \$10\leq n\leq72\$ representing the **height** of the output described below.
Output: A matrix (actual type: 2D array or equivalent) of 1s and 0s where a 1 represents a pixel to be coloured black and a 0, white. The matrix is to be scaled to a height of \$n\$, maintaining the glyph's aspect ratio as far as possible. A 1 must appear where and only where, ideally, using vector graphics, **more than or exactly** 50% of the corresponding space would be black.
* For standardisation purposes, compute the output as though there were no whitespace borders in the input.
In every example below, for reasons of clarity only, the output substitutes X for 1 and [space] for 0.
### Examples
Run the following snippet to view them.
```
body { font-family: verdana; }
table, th, td {
border: 1px solid black;
border-collapse: collapse;
}
th, td { padding: 5px; }
td { vertical-align: top; }
.w { width: 60%; }
.g { background-color: #eee; }
.m {
font-family: monospace;
padding: .2em;
}
.a { line-height: .7em !important; }
.s { font-size: 85%; }
```
```
<h2>Example 1</h2>
<table>
<tr><th>Input</th><th>Image from path definition</th></tr>
<tr><td class="w" rowspan="3"><span class="g m">
M 60.0,10.0 L 85.3,79.7 C 86.3,82.3 87.1,84.1 87.9,85.0 C 88.7,85.9 89.8,86.6 91.2,87.1 L 96.6,88.7 L 96.7,91.1 C 91.7,91.0 87.1,90.9 82.9,90.9 C 78.5,90.9 73.4,91.0 67.5,91.1 L 67.3,88.7 L 72.7,87.1 C 73.5,86.8 74.0,86.6 74.3,86.2 C 74.7,85.9 74.8,85.4 74.8,84.7 C 74.8,83.9 74.6,82.9 74.2,81.7 C 73.8,80.4 73.3,78.8 72.5,76.8 L 67.2,61.5 L 39.7,61.5 L 33.7,76.7 C 32.9,78.8 32.3,80.5 31.9,81.8 C 31.4,83.0 31.2,84.0 31.2,84.7 C 31.2,85.4 31.4,85.9 31.7,86.2 C 32.1,86.6 32.6,86.8 33.3,87.0 L 38.6,88.5 L 38.7,91.1 C 33.4,91.0 28.9,90.9 25.5,90.9 C 22.1,90.9 18.3,91.0 14.1,91.1 L 13.8,88.7 L 19.5,86.9 C 21.0,86.4 22.1,85.7 22.7,84.8 C 23.4,83.8 24.2,82.4 25.0,80.3 L 54.1,10.8 L 60.0,10.0 z M 41.8,56.3 L 65.3,56.3 L 54.2,24.9 L 41.8,56.3 z
<br><br>
11
</span><td>
<svg width="125" height="110" xmlns="http://www.w3.org/2000/svg">
<path style="fill:#000;" d="M 60.0,10.0 L 85.3,79.7 C 86.3,82.3 87.1,84.1 87.9,85.0 C 88.7,85.9 89.8,86.6 91.2,87.1 L 96.6,88.7 L 96.7,91.1 C 91.7,91.0 87.1,90.9 82.9,90.9 C 78.5,90.9 73.4,91.0 67.5,91.1 L 67.3,88.7 L 72.7,87.1 C 73.5,86.8 74.0,86.6 74.3,86.2 C 74.7,85.9 74.8,85.4 74.8,84.7 C 74.8,83.9 74.6,82.9 74.2,81.7 C 73.8,80.4 73.3,78.8 72.5,76.8 L 67.2,61.5 L 39.7,61.5 L 33.7,76.7 C 32.9,78.8 32.3,80.5 31.9,81.8 C 31.4,83.0 31.2,84.0 31.2,84.7 C 31.2,85.4 31.4,85.9 31.7,86.2 C 32.1,86.6 32.6,86.8 33.3,87.0 L 38.6,88.5 L 38.7,91.1 C 33.4,91.0 28.9,90.9 25.5,90.9 C 22.1,90.9 18.3,91.0 14.1,91.1 L 13.8,88.7 L 19.5,86.9 C 21.0,86.4 22.1,85.7 22.7,84.8 C 23.4,83.8 24.2,82.4 25.0,80.3 L 54.1,10.8 L 60.0,10.0 z M 41.8,56.3 L 65.3,56.3 L 54.2,24.9 L 41.8,56.3 z"/>
</svg>
</td></tr>
<tr><th>Output</th></tr>
<tr><td><pre class="a g">
X
XX
XXX
X XX
X X
X XX
XXXXXX
X XX
X XX
X X
XXX XXXX
</pre></td></tr></table>
<h2>Example 2</h2>
<table>
<tr><th>Input</th><th>Image from path definition</th><th>Output</th></tr>
<tr><td><span class="g m">
M 40.0,10.0 C 44.3,10.2 48.5,10.2 52.4,10.2 C 56.4,10.2 60.5,10.2 64.8,10.0 L 65.0,12.2 L 58.8,14.0 C 58.0,14.2 57.6,14.7 57.5,15.6 C 57.5,16.7 57.4,18.0 57.4,19.4 C 57.4,20.8 57.4,22.3 57.4,23.9 L 57.4,69.3 C 57.4,72.5 57.3,75.5 57.0,78.2 C 56.8,80.9 56.3,83.3 55.7,85.4 C 55.0,87.5 54.2,89.4 53.0,91.0 C 51.9,92.7 50.4,94.1 48.6,95.4 C 46.9,96.7 44.7,97.8 42.2,98.8 C 39.7,99.8 36.7,100.7 33.3,101.5 L 32.6,99.0 C 36.0,97.5 38.8,95.9 40.7,94.1 C 42.7,92.3 44.2,90.3 45.2,88.0 C 46.3,85.8 46.9,83.2 47.2,80.4 C 47.5,77.6 47.6,74.4 47.6,70.8 L 47.6,24.1 C 47.6,22.4 47.6,20.9 47.6,19.5 C 47.6,18.2 47.6,16.9 47.5,15.8 C 47.5,15.0 47.1,14.4 46.3,14.1 L 40.1,12.2 L 40.0,10.0 Z
<br><br>
20
</span></td><td>
<svg width="125" height="110" xmlns="http://www.w3.org/2000/svg">
<path style="fill:#000;" d="M 40.0,10.0 C 44.3,10.2 48.5,10.2 52.4,10.2 C 56.4,10.2 60.5,10.2 64.8,10.0 L 65.0,12.2 L 58.8,14.0 C 58.0,14.2 57.6,14.7 57.5,15.6 C 57.5,16.7 57.4,18.0 57.4,19.4 C 57.4,20.8 57.4,22.3 57.4,23.9 L 57.4,69.3 C 57.4,72.5 57.3,75.5 57.0,78.2 C 56.8,80.9 56.3,83.3 55.7,85.4 C 55.0,87.5 54.2,89.4 53.0,91.0 C 51.9,92.7 50.4,94.1 48.6,95.4 C 46.9,96.7 44.7,97.8 42.2,98.8 C 39.7,99.8 36.7,100.7 33.3,101.5 L 32.6,99.0 C 36.0,97.5 38.8,95.9 40.7,94.1 C 42.7,92.3 44.2,90.3 45.2,88.0 C 46.3,85.8 46.9,83.2 47.2,80.4 C 47.5,77.6 47.6,74.4 47.6,70.8 L 47.6,24.1 C 47.6,22.4 47.6,20.9 47.6,19.5 C 47.6,18.2 47.6,16.9 47.5,15.8 C 47.5,15.0 47.1,14.4 46.3,14.1 L 40.1,12.2 L 40.0,10.0 Z"/>
</svg>
</td><td><pre class="a g">
XXXXX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
XX
</pre></td></tr></table>
<h2>Example 3</h2>
<table>
<tr><th>Input</th><th>Image from path definition</th></tr>
<tr><td class="w" rowspan="3"><span class="g m">
M 80.0,40.0 C 80.0,50.8 77.1,59.6 71.5,66.3 C 65.8,73.0 58.4,76.9 49.2,77.9 C 51.9,85.6 58.9,89.5 70.1,89.5 C 74.6,89.5 78.7,88.8 82.3,87.4 L 82.8,89.7 C 75.9,95.2 70.5,97.9 66.5,97.9 C 53.9,97.9 45.8,91.4 42.3,78.3 C 31.3,78.3 22.8,75.1 16.7,68.6 C 10.6,62.2 7.5,53.4 7.5,42.3 C 7.5,30.7 10.8,21.6 17.4,14.9 C 24.0,8.1 33.1,4.8 44.8,4.8 C 56.0,4.8 64.7,7.9 70.8,14.2 C 76.9,20.5 80.0,29.0 80.0,40.0 L 80.0,40.0 z M 18.5,40.6 C 18.5,51.5 20.7,59.8 25.1,65.6 C 29.5,71.4 35.9,74.3 44.4,74.3 C 52.8,74.3 59.0,71.7 63.0,66.4 C 67.0,61.2 69.0,52.9 69.0,41.7 C 69.0,31.1 66.9,23.0 62.6,17.3 C 58.4,11.7 51.8,8.8 43.0,8.8 C 34.4,8.8 28.2,11.5 24.3,16.7 C 20.4,22.0 18.5,29.9 18.5,40.6 L 18.5,40.6 Z
<br><br>
10
</span><td>
<svg width="125" height="110" xmlns="http://www.w3.org/2000/svg">
<path style="fill:#000;" d="M 80.0,40.0 C 80.0,50.8 77.1,59.6 71.5,66.3 C 65.8,73.0 58.4,76.9 49.2,77.9 C 51.9,85.6 58.9,89.5 70.1,89.5 C 74.6,89.5 78.7,88.8 82.3,87.4 L 82.8,89.7 C 75.9,95.2 70.5,97.9 66.5,97.9 C 53.9,97.9 45.8,91.4 42.3,78.3 C 31.3,78.3 22.8,75.1 16.7,68.6 C 10.6,62.2 7.5,53.4 7.5,42.3 C 7.5,30.7 10.8,21.6 17.4,14.9 C 24.0,8.1 33.1,4.8 44.8,4.8 C 56.0,4.8 64.7,7.9 70.8,14.2 C 76.9,20.5 80.0,29.0 80.0,40.0 L 80.0,40.0 z M 18.5,40.6 C 18.5,51.5 20.7,59.8 25.1,65.6 C 29.5,71.4 35.9,74.3 44.4,74.3 C 52.8,74.3 59.0,71.7 63.0,66.4 C 67.0,61.2 69.0,52.9 69.0,41.7 C 69.0,31.1 66.9,23.0 62.6,17.3 C 58.4,11.7 51.8,8.8 43.0,8.8 C 34.4,8.8 28.2,11.5 24.3,16.7 C 20.4,22.0 18.5,29.9 18.5,40.6 L 18.5,40.6 Z"/>
</svg>
</td></tr>
<tr><th>Output</th></tr>
<tr><td><pre class="a g">
XXXX
X X
X XX
X X
X X
X X
X X
XXXX
X
XXX
</pre></td></tr></table>
<h2>Example 4</h2>
<table>
<tr><th>Input</th><th>Image from path definition</th><th>Output</th></tr>
<tr><td><span class="g m">
M 80.0,40.0 C 80.0,50.8 77.1,59.6 71.5,66.3 C 65.8,73.0 58.4,76.9 49.2,77.9 C 51.9,85.6 58.9,89.5 70.1,89.5 C 74.6,89.5 78.7,88.8 82.3,87.4 L 82.8,89.7 C 75.9,95.2 70.5,97.9 66.5,97.9 C 53.9,97.9 45.8,91.4 42.3,78.3 C 31.3,78.3 22.8,75.1 16.7,68.6 C 10.6,62.2 7.5,53.4 7.5,42.3 C 7.5,30.7 10.8,21.6 17.4,14.9 C 24.0,8.1 33.1,4.8 44.8,4.8 C 56.0,4.8 64.7,7.9 70.8,14.2 C 76.9,20.5 80.0,29.0 80.0,40.0 L 80.0,40.0 z M 18.5,40.6 C 18.5,51.5 20.7,59.8 25.1,65.6 C 29.5,71.4 35.9,74.3 44.4,74.3 C 52.8,74.3 59.0,71.7 63.0,66.4 C 67.0,61.2 69.0,52.9 69.0,41.7 C 69.0,31.1 66.9,23.0 62.6,17.3 C 58.4,11.7 51.8,8.8 43.0,8.8 C 34.4,8.8 28.2,11.5 24.3,16.7 C 20.4,22.0 18.5,29.9 18.5,40.6 L 18.5,40.6 Z
<br><br>
50
</span></td><td>
<svg width="125" height="110" xmlns="http://www.w3.org/2000/svg">
<path style="fill:#000;" d="M 80.0,40.0 C 80.0,50.8 77.1,59.6 71.5,66.3 C 65.8,73.0 58.4,76.9 49.2,77.9 C 51.9,85.6 58.9,89.5 70.1,89.5 C 74.6,89.5 78.7,88.8 82.3,87.4 L 82.8,89.7 C 75.9,95.2 70.5,97.9 66.5,97.9 C 53.9,97.9 45.8,91.4 42.3,78.3 C 31.3,78.3 22.8,75.1 16.7,68.6 C 10.6,62.2 7.5,53.4 7.5,42.3 C 7.5,30.7 10.8,21.6 17.4,14.9 C 24.0,8.1 33.1,4.8 44.8,4.8 C 56.0,4.8 64.7,7.9 70.8,14.2 C 76.9,20.5 80.0,29.0 80.0,40.0 L 80.0,40.0 z M 18.5,40.6 C 18.5,51.5 20.7,59.8 25.1,65.6 C 29.5,71.4 35.9,74.3 44.4,74.3 C 52.8,74.3 59.0,71.7 63.0,66.4 C 67.0,61.2 69.0,52.9 69.0,41.7 C 69.0,31.1 66.9,23.0 62.6,17.3 C 58.4,11.7 51.8,8.8 43.0,8.8 C 34.4,8.8 28.2,11.5 24.3,16.7 C 20.4,22.0 18.5,29.9 18.5,40.6 L 18.5,40.6 Z"/>
</svg>
</td><td><pre class="a g s">
XXXXXXXX
XXXXXXXXXXXXXXXX
XXXXXXX XXXXXXXXX
XXXXX XXXXXXX
XXXX XXXXXX
XXXX XXXXXX
XXXX XXXXXX
XXXXX XXXXX
XXXXX XXXXXX
XXXXX XXXXX
XXXXXX XXXXXX
XXXXXX XXXX
XXXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXXXX
XXXXX XXXXXX
XXXXXX XXXXXX
XXXXXX XXXXXX
XXXXXX XXXXX
XXXXX XXXX
XXXXXX XXXXX
XXXXXX XXXXX
XXXXXX XXXX
XXXXX XXX
XXXXX XXX
XXXXXX XXX
XXXXXX XXX
XXXXXXX XXX
XXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXX
XXX
XXXX
XXXXX
XXXX
XXXXX
XXXXXX X
XXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX
XXXXXXXXXXX
XXXXX
</pre></td></tr></table>
<h2>Credit</h2>
<a href="https://upload.wikimedia.org/wikipedia/commons/4/4c/Latin_Alphabet.svg">Wikimedia Commons</a>
```
# Remarks
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes wins.
* [Standard rules](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/), [I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) and [loophole rules](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) apply.
* If possible, link an online demo of your code.
* Please explain your code.
[Answer]
# JavaScript (ES7), ~~364~~ 352 bytes
Expects `(path)(height)`.
```
f=
p=>h=>([x,y,X,Y]=[0,1,2,3].map(i=>Math[i&2?'max':'min'](...p.match(/\d+\S+/g).map(s=>+s.split`,`[i&1]))+.5|0),C=document.createElement`canvas`.getContext`2d`).fill(new Path2D(p))&C.getImageData(x,y,X-=x,Y-=y).data.map((v,i)=>!v|i%4-3?0:m[(i>>=2)/X*h/Y|0][i%X*h/Y|0]++,m=[...Array(h)].map(_=>Array(X*h/Y|0).fill(0)))||m.map(r=>r.map(v=>+(v>(Y/h)**2/2)))
o.innerHTML = f("M 80.0,40.0 C 80.0,50.8 77.1,59.6 71.5,66.3 C 65.8,73.0 58.4,76.9 49.2,77.9 C 51.9,85.6 58.9,89.5 70.1,89.5 C 74.6,89.5 78.7,88.8 82.3,87.4 L 82.8,89.7 C 75.9,95.2 70.5,97.9 66.5,97.9 C 53.9,97.9 45.8,91.4 42.3,78.3 C 31.3,78.3 22.8,75.1 16.7,68.6 C 10.6,62.2 7.5,53.4 7.5,42.3 C 7.5,30.7 10.8,21.6 17.4,14.9 C 24.0,8.1 33.1,4.8 44.8,4.8 C 56.0,4.8 64.7,7.9 70.8,14.2 C 76.9,20.5 80.0,29.0 80.0,40.0 L 80.0,40.0 z M 18.5,40.6 C 18.5,51.5 20.7,59.8 25.1,65.6 C 29.5,71.4 35.9,74.3 44.4,74.3 C 52.8,74.3 59.0,71.7 63.0,66.4 C 67.0,61.2 69.0,52.9 69.0,41.7 C 69.0,31.1 66.9,23.0 62.6,17.3 C 58.4,11.7 51.8,8.8 43.0,8.8 C 34.4,8.8 28.2,11.5 24.3,16.7 C 20.4,22.0 18.5,29.9 18.5,40.6 L 18.5,40.6 Z")(20).map(r => r.map(v => ' X'[v]).join('')).join('\n')
```
```
<pre id=o></pre>
```
### Commented
```
p => h => // p = path, h = height
( [x, y, X, Y] = // find the bounding box (x, y) - (X, Y)
[0, 1, 2, 3].map(i => // for i = 0 to 3:
Math[i & 2 ? 'max' : 'min']( // get the max if i > 1, or the min otherwise:
...p.match(/\d+\S+/g) // match all coordinates
.map(s => // for each of them:
+s.split`,`[i & 1] // keep x if i is even, or y if i is odd
) // end of inner map()
) + .5 | 0 // end of Math.min or Math.max; round the result
), // end of outer map()
C = document.createElement // create a canvas and get its 2D context C
`canvas`.getContext`2d` //
).fill(new Path2D(p)) & // draw the path in the canvas
C.getImageData( // turn X into the width and Y into the height
x, y, X -= x, Y -= y //
).data.map((v, i) => // for each value at position i in the context data:
!v | // if v is not set
i % 4 - 3 ? // or this is not a transparency field:
0 // do nothing
: // else:
m[(i >>= 2) / X * h / Y | 0] // increment m[] at the position obtained by
[i % X * h / Y | 0]++, // rescaling ((i >> 2) / X, (i >> 2) % X)
// according to the ratio h / Y
m = // initialize m[] to a matrix of size
[...Array(h)].map(_ => // floor(X * h / Y) x h,
Array(X * h / Y | 0) //
.fill(0) // filled with 0's
) //
) || // end of map()
m.map(r => // for each row r[] in m[]:
r.map(v => // for each value v in m[]:
+(v > (Y / h) ** 2 / 2) // set v to 1 if it's greater than the threshold
) // end of inner map()
) // end of outer map()
```
[Answer]
## HTML5 + ES6, 320 bytes
```
with(c.getContext`2d`)f=(d,h)=>(p.setAttribute("d",d),b=p.getBBox(),c.height=h,c.width=w=h*b.width/b.height,scale(s=h/b.height,s),translate(-b.x,-b.y),fill(new Path2D(d)),[...getImageData(0,0,w,h).data.filter((_,i)=>!(3&~i))].map(i=>` X`[i>>7]).join``.match(RegExp(`.{${c.width}}`,`g`)).join`
`)
console.log(f("M 80.0,40.0 C 80.0,50.8 77.1,59.6 71.5,66.3 C 65.8,73.0 58.4,76.9 49.2,77.9 C 51.9,85.6 58.9,89.5 70.1,89.5 C 74.6,89.5 78.7,88.8 82.3,87.4 L 82.8,89.7 C 75.9,95.2 70.5,97.9 66.5,97.9 C 53.9,97.9 45.8,91.4 42.3,78.3 C 31.3,78.3 22.8,75.1 16.7,68.6 C 10.6,62.2 7.5,53.4 7.5,42.3 C 7.5,30.7 10.8,21.6 17.4,14.9 C 24.0,8.1 33.1,4.8 44.8,4.8 C 56.0,4.8 64.7,7.9 70.8,14.2 C 76.9,20.5 80.0,29.0 80.0,40.0 L 80.0,40.0 z M 18.5,40.6 C 18.5,51.5 20.7,59.8 25.1,65.6 C 29.5,71.4 35.9,74.3 44.4,74.3 C 52.8,74.3 59.0,71.7 63.0,66.4 C 67.0,61.2 69.0,52.9 69.0,41.7 C 69.0,31.1 66.9,23.0 62.6,17.3 C 58.4,11.7 51.8,8.8 43.0,8.8 C 34.4,8.8 28.2,11.5 24.3,16.7 C 20.4,22.0 18.5,29.9 18.5,40.6 L 18.5,40.6 Z",50))
```
```
<canvas id=c><svg><path id=p />
```
Explanation: The HTML creates two global variables, `c` being the canvas element and `p` being the SVG path element.
```
with(c.getContext`2d`)
```
Put all of the canvas's 2d drawing functions into the current scope.
```
f=(d,h)=>(
```
Create a function of two parameters.
```
p.setAttribute("d",d),b=p.getBBox(),
```
Set the `d` attribute of the path and then get its bounding box.
```
c.height=h,c.width=w=h*b.width/b.height,
```
Set the size of the canvas to the desired height and scale the width.
```
scale(s=h/b.height,s),translate(-b.x,-b.y),
```
Scale and translate the drawing to fit the desired height.
```
fill(new Path2D(d)),
```
Draw the path on the canvas.
```
[...getImageData(0,0,w,h).data.filter((_,i)=>!(3&~i))].
```
Get the alpha channel of the canvas.
```
map(i=>` X`[i>>7]).
```
Map the dark pixels to `X` and the light pixels to space.
```
join``.match(RegExp(`.{${w}}`,`g`)).join`
`)
```
Rewrap the pixels to the width of the canvas.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/205597/edit).
Closed 3 years ago.
[Improve this question](/posts/205597/edit)
### Introduction
Windows 95 used a very simple algorithm for verifying license keys. The scheme of an OEM license key always looked like this:
```
xxxyy-OEM-NNNNNNN-zzzzz
```
The day can be anything within 001-366, and the year cannot be lower than 95 or above 03.
`xxx` represents the day of the year the key was printed on (for example 192 = 10th of July) and is a number between 001-366.
`yy` represents the year the key was printed on and cannot be lower than 95 or above 03.
This means for example, a key with 19296 as the first segment was printed on 10th of July 1996.
The second segment is always OEM.
The third segment (NN..) is always starts with `00` and the sum of the digits has to be divisible by 7
The fourth segment is irrelevant, provided the field is the appropriate length, but has to be filled out with digits.
### Challange
Given a string, output a truthy or falsy value whether this oem key is valid or not.
### Rules
* You may provide a function or a program
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the least amount of bytes wins!
### Test cases
## Valid keys
```
12899-OEM-0042134-31009
15795-OEM-0001355-07757
35201-OEM-0009165-64718
```
## Invalid keys
```
12804-OEM-0033143-31009
16595-OEM-0001695-9
12899-OEM-0022134-31009
27497-OEM-0525347-80387
```
[Answer]
# perl -pl -MList::Util=sum, 106 113 bytes
```
$_=/^(?!000)(([012]\d\d|3([0-5]\d|6[0-5]))(9[5-9]|0[0-3])|366(00|96))-OEM-00(\d{5})-\d{5}$/&&!(sum(split//,$6)%7)
```
[Try it online!](https://tio.run/##bZBPS8QwEMXv/RRdqEsCDp1kMkmzsHjy5uLJ07Z6qYdCdYutJ@tXN6b/YAXnMm9@zLwX0r1@tBxC9nLMn8XdDhGlEGdUuirrsh4pauCoRzsLKYU/M/hqxDhTJUeyViCO3koJj/cnQBRl/cXfEuaW5fv9TvSfb6Lv2mbI89vMyhsnQ4hR3q8nRisyQCqiROnif87O88pRETOgc@wSYo1q415ZBmucKiYfNCsnUoYWnzRNk7h0ZWWj/hurr2K1M94tnDWTcVAgFTHWWsTNY6qlz3x7jptq4T@Xbmgu732Arg1wemj64XB4Gpr2GP/mFw "Perl 5 – Try It Online")
This assumes an ASCII only input. If the input can be outside of ASCII, we'd have to add a single extra byte (a trailing `a` modifier on the main regexp). It also assumes a leading `366` can only occur in the years `96` and `00`, them being leap years. The bulk of the matching is done by a regexp; testing of divisibility by 7 is done outside of it.
Reads keys from `STDIN`; writes `1` to `STDOUT` for valid keys, empty lines for invalid keys.
Edit: fixed the issue mentioned by @Dingus.
[Answer]
# [Ruby](https://www.ruby-lang.org/) -n, 110 bytes
```
p~/^(\d{3})(9[5-9]|0[0-3])-OEM-(00\d{5})-\d{5}$/&&$3.to_i.digits.sum%7<1&&$1>?0*3&&$1<"36#{$2=~/6|0$/?7:6}"||p
```
[Try it online!](https://tio.run/##TY3NasJQEIX3eQwbJSlMMnPnzp3cYuuqS@kDqC2IIFnUhCYuxMRH723qD2R1Dt@B7/wct6cQ6kv@max3Z@7TxK8E/KbDFQJvUvh4X0KCOIzSp3CNOJ/NYs7a6qvMduW@bJusOX5PdU4Dp7cFPvN/mU/YPZ1j83rJXYdxvtAX10@6rg6BTOH9VY1oDbEFJkQfkaiXO0diEUBV0YjFID24JyfgrFIRDR60d85Mlh8eJyOPG7qPxp9m9GnUer1xMcJWoUAu9Leq27I6NAEOfw "Ruby – Try It Online")
Takes input on STDIN. Outputs `true` to STDOUT for valid keys and `nil` for invalid keys.
Uses three regex capture groups: `$1` is `xxx`, `$2` is `yy`, and `$3` is `NNNNNNN`. First tests whether the key has the correct general format. If so, then tests whether the sum of digits in `$3` is divisible by 7. Then tests whether `$1` is lexicographically greater than `'000'` and less than either `'366'` (non-leap years) or `'367'` (leap years); this works because we know at this point that `$1` is a string of three digits. Leap years occur when `$2` contains `6` or ends with `0`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~73~~ ~~85~~ 78 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
•J" L•S£ε"©366L ₃Ƶ2Ÿт%y4Ö≠i®366Ê* '- …OEM '- 0мõ ÐþQ×SO7Ö1 '- ÐþQ×g5"#Nè.VQà}P
```
+12 bytes to account for leap years.
Will try to golf it down from here. If only 05AB1E had regex.. :/
[Try it online](https://tio.run/##yy9OTMpM/f//UcMiLyUFHyAVfGjxua1Kh1Yam5n5KDxqaj621ejojotNqpUmh6c96lyQeWgdUOZwl5aCuq7Co4Zl/q6@IJbBhT2HtyocnnB4X@Dh6cH@5oenGYKEoQLppkrKfodX6IUFHl5QG/D/v6GRhaWlLlCrroGBiZGhsYmusaGBgSUA) or [verify a lot more test cases](https://tio.run/##dZG/SgNBEMZfZVkVQW5l9v9dFVRiIYlnCNiIhULQQCCFIKQQQgRBK7GIbVCQ2NgdWIjFLVqKvsK9yLmbS86c4ZaFHb4fM9/MbPfs6LjdSs97FYySqzuEK7006T/sYFSzTzN@/Ipw/MyVqqFkcPkZsY/Xn8FKT5hhcj1qxy@WmJs1tEpQ0n8Kq3UXwfebiZC5Ne8Nc98MtRlSJ0@FE4mXds14fb9hRhd7qZceYMr8ICA2mwAIRrkgnAIE2MNU6kBOCVAuJQGtpbaESwZ0RgKqJFFCU98RpQBmxJ3sxR5yRiCmiHMq@J@RknNGysYTda4xVmiMaRHojEgmudDEB@7rzD6vVBxmOwyXGScbm1sLpecayXUu/u0iJwQWSD5WkRAKZZudVKvWwxJSyGmVEpfjEJT/ob2nrU6niw9/AQ).
**Explanation:**
```
•J" L• "# Push compressed integer 321312516
S # Convert it to a list of digits: [3,2,1,3,1,2,5,1,6]
£ # Split the (implicit) input-string into parts of that size
ε # Map each part to:
"©366L ₃Ƶ2Ÿт%y4Ö≠i®366Ê* '- …OEM '- 0мõ ÐþQ×SO7Ö1 '- ÐþQ×g5"
# Push this string
# # Split the string on spaces
Nè # Use the map-index to index into this string
.V # Evaluate/execute it as 05AB1E code
Q # Check that the top two values on the stack are equal
à # Pop and take its maximum (no op if it's already a single 0/1 boolean)
}P # After the map: check if all were truthy by taking the product
# (after which the result is output implicitly)
```
As for each individual part:
```
# xxx:
© # Store the string in variable `®` (without popping)
366L # Push a list in the range [1,366]
# After the eval:
Q # Check for each value whether it's equal to the current `xxx` part
à # Check if any are truthy in this list by taking the maximum
# yy:
₃ # Push builtin 95
Ƶ2 # Push compressed integer 103
Ÿ # Pop both an push a list in the range [95,103]
т% # Take modulo-100 on each value
y # Push the current `yy` part again
4Ö≠i # If it's NOT divisible by 4 (so neither 96 nor 00):
® # Push the `xxx` part from variable `®`
366Ê # Check that it's NOT equal to 366
* # And check if both are truthy by multiplying them together
} # (implicit due to the eval: close the if-statement)
# After the eval:
Q # Check for each value whether it's equal to the current `yy` part
à # Check if any are truthy in this list by taking the maximum
# OEM:
…OEM # Push string "OEM"
# After the eval:
Q # Check if it's equal to the current `OEM` part
à # No-op maximum, since the max digit of 0/1 is 0/1 respectively
# 00:
0м # Remove all 0s from the current `00` part
õ # Push an empty string ""
# After the eval:
Q # Check if the `00` part with zeroes is equal to the empty string
à # No-op maximum, since the max digit of 0/1 is 0/1 respectively
# NNNNN:
Ð # Triplicate the current `NNNNN` part
þ # Pop and only leave its digits
Q # Check that it's equal to the `NNNNN` part (1 if truthy; 0 if falsey)
× # Repeat the part that many times (`NNNNN` if truthy; "" if falsey)
S # Convert it to a list of characters
O # Sum those digits together
7Ö # Check that it's divisible by 7
1 # Push a 1
# After the eval:
Q # Check whether the divisibility check is equal to the 1
à # No-op maximum, since the max digit of 0/1 is 0/1 respectively
# zzzzz:
ÐþQ× # Similar as above for NNNNN
g # Pop and push its length
5 # Push a 5
# After the eval:
Q # Check if the length is equal to the 5
à # No-op maximum, since the max digit of 0/1 is 0/1 respectively
# -:
'- '# Push a "-"
# After the eval:
Q # Check if the `-` part is equal to the "-"
à # No-op maximum, since the max digit of 0/1 is 0/1 respectively
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `•J" L•` is `321312516` and `Ƶ2` is `103`.
] |
[Question]
[
**This question already has answers here**:
[Generate Monday Numbers](/questions/59014/generate-monday-numbers)
(49 answers)
[Is it a Lynch-Bell number?](/questions/129773/is-it-a-lynch-bell-number)
(44 answers)
Closed 5 years ago.
A natural number (written in the decimal base) is qualified as **digisible** if and only if it fulfills the following 3 conditions:
1. none of its digits is zero,
2. all the digits that compose it are different,
3. the number is divisible by all the digits that compose it.
The challenge is to output all the digisibles (there are 548 digisibles).
## Examples
```
1 --> the smallest digisible
24 --> is digisible
2789136 --> is digisible
2978136 --> is digisible
2983176 --> is digisible
3298176 --> is digisible
3678192 --> is digisible
3867192 --> is digisible
3928176 --> is digisible
6387192 --> is digisible
7829136 --> is digisible
7836192 --> is digisible
7892136 --> is digisible
7892136 --> is digisible
9867312 --> the biggest digisible
1653724 --> is not digisible
1753924 --> is not digisible
23 --> is not digisible
2489167 --> is not digisible
5368192 --> is not digisible
60 --> is not digisible
7845931 --> is not digisible
8964237 --> is not digisible
9129 --> is not digisible
```
## Input
No input.
## Output
The list (or set) of all digisibles. The output does not have to be sorted.
## Complete output
```
1
2
3
4
5
6
7
8
9
12
15
24
36
48
124
126
128
132
135
162
168
175
184
216
248
264
312
315
324
384
396
412
432
612
624
648
672
728
735
784
816
824
864
936
1236
1248
1296
1326
1362
1368
1395
1632
1692
1764
1824
1926
1935
1962
2136
2184
2196
2316
2364
2436
2916
3126
3162
3168
3195
3216
3264
3276
3492
3612
3624
3648
3816
3864
3915
3924
4128
4172
4236
4368
4392
4632
4872
4896
4932
4968
6132
6192
6312
6324
6384
6432
6912
6984
8136
8496
8736
9126
9135
9162
9216
9315
9324
9432
9612
9648
9864
12384
12648
12768
12864
13248
13824
13896
13968
14328
14728
14832
16248
16824
17248
18264
18432
18624
18936
19368
21384
21648
21784
21864
23184
24168
24816
26184
27384
28416
29736
31248
31824
31896
31968
32184
34128
36792
37128
37296
37926
38472
39168
39816
41328
41832
42168
42816
43128
43176
46128
46872
48216
48312
61248
61824
62184
64128
68712
72184
73164
73248
73416
73962
78624
79128
79632
81264
81432
81624
81936
82416
84216
84312
84672
87192
89136
89712
91368
91476
91728
92736
93168
93816
98136
123648
123864
123984
124368
126384
129384
132648
132864
132984
134928
136248
136824
138264
138624
139248
139824
142368
143928
146328
146832
148392
148632
149328
149832
162384
163248
163824
164328
164832
167328
167832
168432
172368
183264
183624
184392
184632
186432
189432
192384
193248
193824
194328
194832
198432
213648
213864
213984
214368
216384
218736
219384
231648
231864
231984
234168
234816
236184
238416
239184
241368
243168
243768
243816
247968
248136
248976
261384
263184
273168
281736
283416
284136
291384
293184
297864
312648
312864
312984
314928
316248
316824
318264
318624
319248
319824
321648
321864
321984
324168
324816
326184
328416
329184
341928
342168
342816
346128
348192
348216
348912
349128
361248
361824
361872
362184
364128
364728
367248
376824
381264
381624
382416
384192
384216
384912
391248
391824
392184
394128
412368
413928
416328
416832
418392
418632
419328
419832
421368
423168
423816
427896
428136
428736
431928
432168
432768
432816
436128
438192
438216
438912
439128
461328
461832
463128
468312
469728
478296
478632
481392
481632
482136
483192
483216
483672
483912
486312
489312
491328
491832
493128
498312
612384
613248
613824
613872
614328
614832
618432
621384
623184
623784
627984
631248
631824
632184
634128
634872
641328
641832
643128
648312
671328
671832
681432
684312
689472
732648
732816
742896
746928
762384
768432
783216
789264
796824
813264
813624
814392
814632
816432
819432
823416
824136
824376
831264
831624
832416
834192
834216
834912
836472
841392
841632
842136
843192
843216
843912
846312
849312
861432
864312
873264
891432
894312
897624
912384
913248
913824
914328
914832
918432
921384
923184
927864
931248
931824
932184
934128
941328
941832
943128
948312
976248
978264
981432
984312
1289736
1293768
1369872
1372896
1376928
1382976
1679328
1679832
1687392
1738296
1823976
1863792
1876392
1923768
1936872
1982736
2137968
2138976
2189376
2317896
2789136
2793168
2819376
2831976
2931768
2937816
2978136
2983176
3186792
3187296
3196872
3271968
3297168
3298176
3619728
3678192
3712968
3768912
3796128
3816792
3817296
3867192
3869712
3927168
3928176
6139728
6379128
6387192
6389712
6391728
6719328
6719832
6731928
6893712
6913872
6971328
6971832
7168392
7198632
7231896
7291368
7329168
7361928
7392168
7398216
7613928
7639128
7829136
7836192
7839216
7861392
7863912
7891632
7892136
7916328
7916832
7921368
8123976
8163792
8176392
8219736
8312976
8367912
8617392
8731296
8796312
8912736
8973216
9163728
9176328
9176832
9182376
9231768
9237816
9278136
9283176
9617328
9617832
9678312
9718632
9723168
9781632
9782136
9812376
9867312
```
## Rules
* The output can be given [in any convenient format](http://meta.codegolf.stackexchange.com/q/2447/42963).
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* If possible, please include a link to an online testing environment so other people can try out your code!
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
[Answer]
# [Haskell](https://www.haskell.org/), 83 bytes
-1 byte thanks to @Laikoni, -13 bytes thanks to @H.PWiz!
```
f=[n|n<-[1..10^7],x<-[show n],and[d>'0'&&n`mod`read[d]<1|d<-x],[a|a<-x,b<-x,a==b]==x]
```
[Try it online!](https://tio.run/##FYhBDkAwEAC/sgfhUqInl66PNCtWSgiWINFD/151mczMzPc6bluME1oJYkqrq0rXXUPKp7jn4wUhxeKsa4u6yHPp98P118jpkNHBmdKTshw4iRp@MOJAiJ7izosAwnkt8kAGU/wA "Haskell – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~28~~ 23 bytes
```
ΦＥＸχ⁷Ｉι∧Πι¬Φι∨⁻μ⌕ιλ﹪κＩλ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMtM6cktUjDN7FAIyC/HMgyNNBRMNXUUXBOLC7RyNQEshzzUjQCivJTSpNBAjoKfvlwbZk6Cv5AzZl5pcUauToKbplApUCxHJA2X6COnHyNbKhRQDEIsP7//79uWQ4A "Charcoal – Try It Online") for numbers of up to five digits (too slow for larger numbers). Explanation:
```
χ Predefined variable 10
Ｘ Raised to power
⁷ Literal 7
Ｅ Map over implicit range
ι Current value
Ｉ Cast to string
Φ Filter over list of strings
ι Current string
Π Digital product (is nonzero)
∧ Logical And
¬ Logical Not
ι Current string
Φ Filter over digits as characters
μ Inner index
⁻ Minus
⌕ First position of
λ Current character in
ι Current string
∨ Logical Or
κ Outer index
﹪ Modulo
λ Current character
Ｉ Cast to integer
```
[Answer]
# [Python 3](https://docs.python.org/3/), 132 bytes
```
for i in range(1,int(1e7)):
if '0' not in str(i) and len(set(str(i)))==len(str(i)) and not any([i%int(j) for j in str(i)]):print(i)
```
[Try it online!](https://tio.run/##RY2xCoRAEEN7vyKNOAMWJxaC4JeIxcKtdyMyK@s0fv0eo8WVSV6S47Jv0r6UNWUIRJGDfiJ1rahRFwfmsYKsaF4NNJkTp2USRtA39qh0RqPHYp6m23nUTXgn6EWz1L64Mfxp@@8sPB7ZI@FSfg "Python 3 – Try It Online")
] |
[Question]
[
*Inspired by ["You had me at hello"](https://codegolf.stackexchange.com/questions/115207/you-had-me-at-hello)*
# Introduction
For those who don't know, hexadecimal is a base system like decimal. Contrary to decimal however, it uses 16 (hence the name) digits instead of 10.
Here are the first few numbers while counting up in hexadecimal to maybe give you a feel of things, although you should probably google it for more info.
`0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 1C, 1D, 1E, 1F, 20...`
From now on I'll refer to hexadecimal as hex.
---
# Challenge
Take a possibly infinite stream of bytes, and convert it to hex. This should be done as you read since you might get an infinite stream and keep on reading forever.
The twist, is that if a sequence of converted numbers equals the exact hex number `DEADBEEF` (3735928559 in decimal), you must output `FEEDBEEF` (4276993775 in decimal) instead.
If no `DEADBEEF` is found, print the string as it was
Inter-character matches work too, so `2D EA DB EE F0` works and should be converted to `2F EE DB EE F`
---
# Example
This might seem a bit vague, so here are 2 step-by-step examples.
### Example 1
Input: `Hello, World` (bytes represented as string)
>
> Step 1: Convert the input to ASCII: `072 101 108 108 111 044 032 087 111 114 108 100`
>
>
> Step 2: Convert the ASCII to hex: `48 65 6C 6C 6F 2C 20 57 6F 72 6C 64`
>
>
> Step 3: Print out everything until `DEADBEEF` is found. It wasn't found, so just print `Hello, World` again.
>
>
>
### Example 2
Input: `Hello,Þ¾ï,,`
>
> Step 1: Convert to ASCII: `72 101 108 108 111 44 222 173 190 239 44 44`
>
>
> Step 2: Convert to hex: `48 65 6C 6C 6F 2C DE AD BE EF 2C 2C`
>
>
> Step 3: Is there `DEADBEEF`? Yep. so take everything up to it. `48 65 6C 6C 6F 2C`
>
>
> Step 4: Append `FEEDBEEF` to it. `48 65 6C 6C 6F 2C FE ED BE EF`
>
>
> Step 5: Convert back to a string and print it. Output is `Hello,þí¾ï`
>
>
>
---
# Scoring
Try to make a program that does the above in the **fewest bytes of source code as possible**.
---
# Remember!
Make sure your program works for finite and infinite streams. The stream can be STDIN, file, function argument (if you can pass streams as arguments), or your language's closest alternative. Output is to STDOUT or function returning (if you can return streams).
# More test cases (contain invisible characters)
`eeþí¾Þ¾ïe (6565feedbedeadbeef65) -> eeþí¾þí¾ïe`
`Þ¾ï (deadbeef)-> þí¾ï`
`Þ=êÛîôV -> Þ?îÛîôV`
[Answer]
# [Python 3](https://docs.python.org/3/), 121 bytes
```
I=open(0).read
p=print
x=i=I(1)
while i:p(end=x[:-4]);x=x[-4:];x!='Þ¾ï'or+p(end='þí¾ï');i=I(1);x+=i
p(end=x[:5])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/39M2vyA1T8NAU68oNTGFq8C2oCgzr4SrwjbT1lPDUJOrPCMzJ1Uh06pAIzUvxbYi2krXJFbTugLI0jWxirWuULRVPzzv0NpD@w6vV88v0oYoUz@87zBESNMaYo51hbZtJhfcENNYzf//PVJzcvJ1YLp1dAA "Python 3 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~34~~ 30 bytes
*-4 bytes from @Shagy*
```
csG r`Ü%¼ef.+``fe‚¼ef` ò ®nG d
```
[Try it online!](https://tio.run/##y0osKPn/P7nYXaEo4fAc1UN7UtP0tBMS0lIPNYHYCQqHNykcWpfnrpDy/7@SR2pOTr6OwuF5h9Ye2nd4vY6OkoJuAAA "Japt – Try It Online")
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 143 bytes
*uses octal escapes here and on TIO to prevent UTF-8 mangling, but it does work with the actual values and so each escape sequence is counted as one byte*
This one works with inter-character sequences.
```
import StdEnv
$l=:[a,'\352\333\356',b:t]|(toInt a)rem 16==13&&(toInt b)>>4==15=[a+'\002':['\356\333\356\015']]=[hd l: $(tl l)]
$['\336\255\276\357':_]=['\376\355\276\357']
$[h:t]=[h: $t]
$e=e
```
[Try it online!](https://tio.run/##bU5Na4NAED3HXzEHyUbyrdUUYXNqSwOFHpKedAmjjlVY3ZDdJBT622vX0A8KPc3Me2/ee7kkbLtGFSdJ0GDddnVzUEcDW1Pct2fHlTxOcMLSIPTTIAjsjNgki414Hxm1aQ2gd6QGlhHny2A4/AIzb72@sUjIExyzdLHwWZz0JtG3SbpYhkwInlQFyBjckZEgPeG4vSyIUj8MU39l5eGKxXurs/D1/IV7cWWbWA9rYOxJnLqtQVufgwujhD2SlGrCBIzHUBAWGVHZ7wnTqiFQpqIjaHMqSxbXbVm3taF9XuFRC8@5WJKcwc8fh3@6CZjPIaMcT5pgt3kGOzW87B6mt6AVXAgqPBMY1ROgcoMSSOd4IO0M/kZeA5DNZqL7yEuJr7qbbp66u7cWmzrXnw "Clean – Try It Online")
# [Clean](https://github.com/Ourous/curated-clean-linux), 38 bytes
*uses octal escapes here and on TIO to prevent UTF-8 mangling, but it does work with the actual values and so each escape sequence is counted as one byte*
This one does not work with inter-character sequences.
```
$['\336\352\276\357':_]=['\376\355\276\357']
$[h:t]=[h: $t]
$e=e
```
[Try it online!](https://tio.run/##bU/LasMwEDzHX7EHg1rygpg0xeBbWxoo9JD05JiwkVe1iiwFa500P19XyiFQ6GlnZ9idGWkI7dC6ujcELWo7pKXYZdnDLlsudotVnCuR76si0td1eaOrJC2bnIPW5JByWKmgQbdH1zFsuH62J5jP4UxQOysYUHKPxlyg9wTcaA/KdQEQqN5K1s5O4Kv3fKPpG9ujoWTDGD4WkMJdKV7JGDcRFYzHUBPWByIVcSm8awlcOOzAc6@UyLVV2mqmvWyw89V9cg4iJaPbXQH/1K1i6gNJjDm36/eY18PH9mX6CN7FPg2eQgN3LeIkowHyEo/kk9Ffy6sBitmsGn6kMvjph@n6bXi6WGy19L8 "Clean – Try It Online")
Defines the function `$ :: [Char] -> [Char]` taking and returning a list of characters.
Since Clean is lazily-evaluated, this is equivalent to a stream.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 30 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÇhJl’–ìÀÜ’¡Dнsg1›’ŽåÀܒ׫2ôHçJ
```
[Try it online](https://tio.run/##yy9OTMpM/f//cHuGV86jhpmPGiYfXnO44fAcIPvQQpcLe4vTDR817ALyju49vBQqcXj6odVGh7d4HF7u9f@/R2pOTr6C7uFVh2cfXnd4g0J5flFOiiIA) or [verify a few more test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/w@0ZXjmPGmY@aph8eM3hhsNzgOxDC10u7C1ON3zUsAvIO7r38FKoxOHph1YbHd7icXi513@d/9FKHqk5OfkKuodXHZ59eN3hDQrl@UU5KYpKOgpKHpkQCqRA5/C8Q2sP7Tu8XkcHLJZfjqQlMSm/tEQBpkKhpDzfXikWAA).
**Explanation:**
```
Ç # Convert the (implicit) input-string to codepoint decimals
h # Convert them to hexadecimal
J # Join them together
l # Convert to lowercase
’–ìÀÜ’ # Push compressed string "deadbeef"
¡ # Split the hexadecimal string by this "deadbeef"
D # Duplicate
н # Take the first item of the split-list
s # Swap so the full list is at the top of the stack again
g1› # Check if its length is larger than 1
’ŽåÀܒ׫ # If it is: concat "feedbeef" to the head-string
2ô # Split the string into parts of size 2
H # Convert hexadecimal back to decimal
ç # Decimal back to characters
J # Join the characters (and output implicitly)
```
[See this 05AB1E tips of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `’–ìÀÜ’` is `"deadbeef"` and `’ŽåÀÜ’` is `"feedbeef"`.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 137 bytes
```
i=16;n;long long u;c;R(k){u=u<<4|c>>k&15,u^=u+'!RA'<<32?0:' @';}main(){for(;n+=!!~(c=getchar(n-=!i&&~putchar(u>>32)));i/=2)R(4),R(0);}
```
[Try it online!](https://tio.run/##XU/bTsJAFOSZN/9girHdDRDb3ZYYt1sFWj6gTz5pyFJqgy6ksEkThF8vFLFGk8lJzmVmzqhhrlRd6B3e8myn3uclodijGVRy6Als1VwvSe@u6g1gV1SgzHam1KgEDt0Lb2O@eUZvi1xnCzQdqkZmU54vGrbLXnAW@M/v3i6yZaEzXL3bJ9rFVbx1qQvpjYQWH2ud41KMUCIlK7o30oSh/6WiaGV7wcC8StN3rHR844QhZ0/uo4PnTscRh895oQndL9clEbovLetIlPxJr4fSKmz72KaKIs4opaK4l4ymxKeDlLhUHOqae@AMnIP74AHcGMkY8QRJgpkHxuEHiBOMY0wSJDO47i/8B4wCjKYXzMCmfy7PLZueAA "C (gcc) – Try It Online")
] |
[Question]
[
**This question already has answers here**:
[Bracket Expansion!](/questions/154345/bracket-expansion)
(18 answers)
Closed 5 years ago.
*Taken from [StackOverflow Question](https://stackoverflow.com/questions/50803170/decodestring-regex-solution/50803311)*
**Challenge**
Given an encoded string in format `n[s]` where `n` is the amount of times `s` will be repeated, your task is to output the corresponding decoded string.
* `n` will always be a positive number
* `s` can not contain empty spaces
* `strings` only contains letters from the alphabet
* `s` length can be `>= 1`
* encoded format is `number [ string ]`
* string can have nested encoded string `number [ number [ string ] ]`
* return the same string if not encoded
**Examples**
```
2[a] => aa
3[2[a]] => aaaaaa
2[b3[a]] => baaabaaa
3[a]5[r3[c]2[b]]a => aaarcccbbrcccbbrcccbbrcccbbrcccbba
a => a // Not Encoded
3 => 3 // Not Encoded
3a3[b] => 3abbb
10[b20[a]] => baaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaa
3[hello] => hellohellohello
```
**Other test cases**
```
a[a] => a[a]
a1[a] => aa
3[] => // Nothing because are 3 empty string
2[2][a] => 2[2][a]
```
---
**This is my own submission.**
```
f=i=>(r=/(\d+)\[([a-z]*)\]/g).test(l=i.replace(r,(m,n,s)=>s.repeat(n)))?f(l):l
console.log(f("2[a]"))
console.log(f("3[2[a]]"))
console.log(f("2[b3[a]]"))
console.log(f("3[a]5[r3[c]2[b]]a"))
console.log(f("a"))
console.log(f("3"))
console.log(f("3a3[b]"))
console.log(f("10[b20[a]]"))
console.log(f("3[hello]"))
```
---
If more test cases needed please tell me.
[Answer]
# [QuadR](https://github.com/abrudz/QuadRS), 17 + `≡` flag = 28 bytes
```
\d+\[\pL*]
∊(⍎⍵M∩⎕D)⍴⊂⍵M∩⎕A
```
[Try it online!](https://tio.run/##KyxNTCn6/z8mRTsmOqbARyuW61FHl8aj3r5HvVt9H3WsfNQ31UXzUe@WR11NCBHH//@Noh1juYyjQVQsl1G0kzGYASJNo4OMo51jgWKxsY5cjlzGXMaOxkAOl6FBtJORAVSdh6uPj38slyPIGEdDiGEgg4xigez/jzoXAgA "QuadR – Try It Online")
Find:
`\d+\[\pL*]` find **d**igit(s) followed by bracketed **L**etters
Replace with:
`⎕A` uppercase **A**lphabet
`⍵M∩` intersection of **M**atch and that
`⊂` enclose (to treat as a whole)
`(`…`)⍴` **r**eshape to length:
`⎕D` **D**igits
`⍵M∩` intersection of **M**atch and that
`⍎` execute (converts text to number)
`∊` **ϵ**nlist (flatten)
---
This is equivalent to the Dyalog APL function:
```
'\d+\[\pL*]'⎕R{∊(⍎⍵.Match∩⎕D)⍴⊂⍵.Match∩⎕A}⍣≡
```
[Answer]
# [Perl 6](https://perl6.org), ~~44~~ 36 bytes
```
{({S{(\d+)\[(<:L>*)\]}=$1 x$0}...*eq*).tail}
```
[Test it](https://tio.run/##1VLLToQwFN3fr7gLIo8ZgYE4i0GIG3fGje6gi7ZUJWEYhI6ZCeKvY4tMNPP4AG/S9rbnnN5HW4umXA7bVuDH0uURwHqPV3yTC4yHzuqeOivLZ3aWWrerh8SxM9LHxgJ3ht@7ruuId8d2JS3KflC6OylaiTGWRSVad03rFXaA6KGVPc1szFoHzTgxcTW6KZqeZ@LnhBL0IkW28Mvw52paoA09gM7sWV0bQV3SCmdjDJXmy6aZ4l0nSmQUVb2VczTErhZcihztMXbRoi7G@sHtP4T5pImgH4KUEjy2OEFKIUw1SM5A2iBIWXiCK5gpUA/Q6E3ahCkniksI/dU3nHPGLs0UKJ4xLVUt9fBxI/G@0sXlEF5ghqdMGqoszjApYwwWfsoC/6ieqZoT@9eHQPWT62bqFejisNUvNnp46N1bUb0iE5zqr0gboboq1rXcYysbBakvEJBJPbnf "Perl 6 – Try It Online")
```
Nil while s{(\d+)\[(<:L>*)\]}=$1 x$0
```
[Test it](https://tio.run/##1VLbSsQwEH3PVwy4sDe0l@A@rO6@@Sb7A2keJmm0hbYpSeoF8detibYI2@4HeCBhmHNmyJlJq0y166/AqFq/KHCF8qHtKgc5OoQno@ufZNm0nSM2gsxuYXk4whJuNhBFd/2prOC1KCsF9mOV5dt1xlb3@8fjZp3xz8MigbdF3PcpQw7n8G0QCWWB5DNUAEmZoBPe08KT4ZDA3jJDmeReyzn@1RsppRCXbiQIMwil4K3BSTt4aKTOVU7oBSWdKpH6V8woUQhBkpiJND7zM7iZ4F8nCQ4rD/MMIcHkNzOunY/mYRxiUTbPIJTEzipAo/x4Vd26d7DOeMr/hZSHHr5mCL9060rd2P66/QY "Perl 6 – Try It Online") (with `-p`)
## Expanded:
```
Nil # silence warning by using Nil rather than 0
while # do the above while the following is truish
s { # string replace (implicitly on $_)
( \d+ ) # capture a series of digits into $0
\[
( <:L>* ) # capture letters
\]
} = $1 x $0 # replace it with the string repeated by the number
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 24 bytes
```
+`(\d+)\[(\p{L}*)]
$1*$2
```
[Try it online!](https://tio.run/##LYw9CoAwDIX3nKOD1cUmeAtvkAaMWlAQFXETz15bdXl/PL4jnPOqLsaqK/xYWc@F36/2Lq2AcaXBGJFVgDibAHJPb8ja8EE8SNpEFBQISCkVcDX3WP@/KSzLJqAZo@6DZRBKyg8 "Retina – Try It Online")
Updated to support additional test cases. -1 thanks to [@Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m)!
[Answer]
## Perl 5, 36 bytes
```
0while s/(\d+)\[([a-z]*)]/$2x$1/e
```
[Answer]
# Japt v2.0a0, 19 bytes
```
e/(\d+).(\l+)]/@ZpY
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=ZS8oXGQrKS4oXGwrKV0vQFpwWQ==&input=IjNbYV01W3IzW2NdMltiXV1hIg==)
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 21 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
è/g1┘+α╣m?╣t╥ó⌂ß─"H║à
```
[Run and debug it](https://staxlang.xyz/#p=8a2f6731d92be0b96d3fb974d2a27fe1c42248ba85&i=%222[a]%22%0A%223[2[a]]%22%0A%222[b3[a]]%22%0A%223[a]5[r3[c]2[b]]a%22%0A%22a%22%0A%223%22%0A%223a3[b]%22%0A%2210[b20[a]]%22%0A%223[hello]%22%0A%22a[a]%22%0A%22a1[a]%22%0A%223[]%22%0A%222[2][a]%22&a=1&m=2)
[Answer]
# [ReRegex](https://github.com/TehFlaminTaco/ReRegex), 83 bytes
```
#import base
(\d+)\[([a-z]+)]/Au<$1>,$2,B/_,([a-z]+),/,$1,$1/A,.*?,(.*?)B/$1/#input
```
ReRegex is a language designed around regex. Sadly, it doesn't really understand numbers. So repeating the string is the hardest part of this.
[Try it online!](https://tio.run/##K0otSk1Prfj/XzkztyC/qEQhKbE4lUsjJkVbMyZaIzpRtypWWzNW37HURsXQTkfFSMdJP14HJq6jr6NiCET6jjp6WvY6GkBC00kfyFfOzCsoLfn/39AgOsnIIDoxNvY/AA "ReRegex – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 158 bytes
```
func[s][b: charset[not"[]"]d: charset"0123456789"until[r: on
parse s[to remove[copy n any d"["copy t any b"]"](insert/dup
c: copy""t do n r: off)insert c]r]s]
```
[Try it online!](https://tio.run/##ZYzNqsIwEIX3fYphVrq6baNebx/jbodZpPnBQk1KkgoiPntNFSTobs73nTnB6OXfaOLKdoudnaLI1HegTjJEk8j5hMTI@o2wblqx2x9@j384uzSMFDrwrppWC5GSh2DO/mJI@ekKDqS7gkbCZ0zP2GOe3AwumpB@9DxVKs9njZhA@/yzTlq7fTVAceDIyxQGl8DCrSXJ9@odBa2gJC314gOteU9BkOJsmWXhyluUtxS5WoCmpr6tv5ZPZhw9w315AA "Red – Try It Online")
## More readable:
```
f: func [ s ] [
b: charset [ not "[]" ]
d: charset "0123456789"
until [
r: on
parse s [
to remove [ copy n some d "[" copy t any b "]" ]
( insert/dup c: copy "" t do n
r: off )
insert c ]
r
]
s
]
```
] |
[Question]
[
**This question already has answers here**:
[Test a number for narcissism](/questions/15244/test-a-number-for-narcissism)
(77 answers)
Closed 6 years ago.
Given a natural numbers `n>1`, find the smallest narcissistic number of `n` digit.
A [narcissistic number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number which is the sum of its own digits, each raised to the power of the number of digits.
For example, for `n=3` (3 digits) the out put should be `153`:
`1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
For `n=4` (4 digits) the out put should be `1634`:
`1^4 + 6^4 + 3^4 + 4^4 = 1 + 1296 + 81 + 256 = 1634`
For `n=5` (5 digits) the out put should be `54748`:
`5^5 + 4^5 + 7^5 + 4^5 + 8^5 = 54748`
If there is no such numbers, like for example `n = 2` or `n = 22` output any special output (a negative number, an exception, an error, empty,...).
**Winning Criteria**
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes by language wins.
[**OEIS A005188**](https://oeis.org/A005188)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~16~~ 15 bytes
Very inefficient.
Empty output if there is no solution.
```
°LʒDSImOQ}ʒgQ}н
```
[Try it online!](https://tio.run/##MzBNTDJM/f//0AafU5Ncgj1z/QNrT01KD6y9sPf/fxMA "05AB1E – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 20 bytes
```
hfqTsm^dQjT10r^TtQ^T
```
[Try it online!](https://tio.run/##K6gsyfj/PyOtMKQ4Ny4lMCvE0KAoLqQkMC7k/39jAA "Pyth – Try It Online")
How it works...
```
hfqTsm^dQjT10r^TtQ^T Implicit: Q=input()
^T 10^Q (final Q is inferred)
^TtQ 10^(Q-1)
r Range over the above
(generates list of numbers of length Q)
f Filter each element in the above (as T) over...
jT10 Get digits in T
m Map each digit in the above (as d) over...
^dQ d^Q
s Sum these
qT Is the above equal to the original number?
h Take the first element of this filtered list
```
Throws an error if no solutions exist.
[Answer]
# JavaScript (ES7), ~~82~~ 79 bytes
*Saved 3 bytes thanks to [@ThePirateBay](https://codegolf.stackexchange.com/users/72349/thepiratebay)*
Returns `undefined` when there's no solution. Reasonably fast up to `n = 7` and really slow beyond that.
```
n=>[...Array(10**n).keys()].find(x=>x==eval([...x+='0'].join(`**${n}+`))&&x[n])
```
### Demo
```
let f =
n=>[...Array(10**n).keys()].find(x=>x==eval([...x+='0'].join(`**${n}+`))&&x[n])
for(n = 2; n < 6; n++) {
console.log(n, f(n))
}
```
---
# Recursive version, 72 bytes
Returns `"0"` (as a string) when there's no solution. For `n > 4`, it would require to either enable Tail-Call-Optimization (not tested) or extend the maximum size of the call stack.
```
f=(n,x=1)=>eval([...s=x+'0'].join(`**${n}+`))-x|!s[n]?s[n+1]||f(n,x+1):x
```
```
f=(n,x=1)=>eval([...s=x+'0'].join(`**${n}+`))-x|!s[n]?s[n+1]||f(n,x+1):x
for(n = 2; n < 5; n++) {
console.log(n, f(n))
}
```
] |
[Question]
[
The date 0409·01·MO is New Year’s Day in the Ceres Calendar. Wish everyone and everything in the [Asteroid Belt](https://dawn.jpl.nasa.gov/), [Jupiter](https://www.nasa.gov/mission_pages/juno/main/index.html), [Saturn](https://saturn.jpl.nasa.gov/) and [beyond](https://www.nasa.gov/mission_pages/newhorizons/main/index.html) a belated Happy New Year by writing a program to convert Julian Dates (JD) to Ceres Dates using these helpful landmarks:
```
JD CMJD Ceres Date (& Time*) ISO 8601 (approx.)
Start of Ceres calendar 2309103.500 0.000 0000·01·MO 00:00 1610
Start of JD calendar 0.000 -2309103.500 -6344·17·MO 4713 BCE
Earliest recorded eclipse 501822.000 -1807281.500 -4966·49·SU 3339 BCE
Battle of Megiddo 1189360.000 -1119743.500 -3077·41·FR 1456 BCE
Battle of Halys 1507900.000 -801203.500 -2202·47·WE 584 BCE
Alexander the Great (b) 1591596.000 -717507.500 -1972·43·SU 355 BCE
Crab Nebula supernova 2106216.000 -202887.500 -0558·33·MO 1054
Discovery of Galilean moons 2309107.000 3.500 0000·01·TH 1610
Discovery of Titan by Huygens 2325616.000 16512.500 0045·19·SU 1655
Discovery of Uranus by Herschel 2371629.000 62525.500 0171·41·TU 1781
Discovery of Ceres by Piazzi 2378862.000 69758.500 0191·34·TH 1801
Discovery of Pallas by Olbers 2379313.000 70209.500 0192·46·SU 1802
Discovery of Juno by Harding 2380201.000 71097.500 0195·17·SA 1804
Discovery of Vesta by Olbers 2381140.000 72036.500 0197·47·SU 1807
Discovery of Astraea by Hencke 2395274.000 86170.500 0236·39·MO 1845
Discovery of Neptune by Galle & Le Verrier 2395563.000 86459.500 0237·28·WE 1846
First Nobel Prizes awarded 2415729.000 106625.500 0292·49·TU 1901-12-10
Archduke Franz Ferdinand (d) 2420312.000 111208.500 0305·27·SU 1914-06-28
Discovery of Pluto by Tombaugh 2426054.000 116950.500 0321·16·TU 1930-03-18
Hiroshima bombing 2431673.469 122569.969 0336·38·SU 23:15 1945-08-05
Dawn probe started exploration of Ceres 2457088.028 147984.528 0406·29·FR 12:40 2015-03-06
Gravitational waves first detected by LIGO 2457279.910 148176.410 0407·05·MO 09:50 2015-09-14
New Year’s Day 0409 2457980.000 148876.500 0409·01·MO 12:00 2017-08-14
```
`CMJD` stands for Ceres Modified JD, a convenient offset. `CMJD` is related to `JD` by the formula:
```
CMJD = JD - 2309103.5
```
The Ceres Calendar has 52 weeks (01 - 52) of seven days, with Monday (MO) as the first day of the week, the rest are TU, WE, TH, FR, SA, & SU and the time synchronized to UTC formatted as HH:MM or HH:MM:SS. There are no leap days in the Ceres Calendar.
\* The Ceres Dates lacking times are only known to the day, so as a convention the middle of the day `12:00` is chosen as the time. Displaying `12:00` for these cases is perfectly acceptable.
Note that the Calendar starts on the Monday before Galileo discovered his satellites, that’s to have the start of the calendar on a Monday to correspond to the [ISO 8601](https://www.cl.cam.ac.uk/~mgk25/iso-time.html) start of the week. The discovery of the Galilean Satellites is more important to them than the Discovery of Ceres but not so important as to mess up the start of the week or the start of the year! That’s just how they roll!
Your program must convert `JD ≥ 0.000` to `Ceres Date` in the format above, using `-` (U+2212 MINUS SIGN) and `·` (U+00B7 MIDDLE DOT) as required. Especially for those using ASCII-only languages, you can substitute `~` (U+007E TILDE) and `*` (U+002A ASTERISK) for the minus sign and middle dot, respectively. The format for dates beyond `9999·52·SU` is undefined.
Here’s a [handy page](http://aa.usno.navy.mil/data/docs/JulianDate.php) to convert to Julian Dates and lots of other useful information.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 92 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
*Definitely beatable by languages with built-in time-formatting or even just better string-formatting.*
```
%1×⁽¢Ẓd60
_“#ḟf’_.µd364Ad0¦7Ẏ;ÇḞ‘2¦ị3¦“TUWETHFRSASUMO”s2¤Ṛ€o0ẋ⁽¡Ḳḃ4¤¤U⁽œọ;“ṢṢ :‘¤Ọ¤żFḊ⁸Ṡ>-¤¡
```
A full program accepting a single argument (decimal number representation) and printing the result.
**[Try it online!](https://tio.run/##y0rNyan8/1/V8PD0R417Dy16uGtSipkBV/yjhjnKD3fMT3vUMDNe79DWFGMzE8cUg0PLzB/u6rM@3P5wx7xHDTOMDi17uLvb@NAyoOqQ0HDXEA@3oGDH4FBf/0cNc4uNDi15uHPWo6Y1@QYPd3WDTF/4cMemhzuaTQ4tObQkFChwdPLD3b3WQM0Pdy4CIgUroJlATbt7Di05usft4Y6uR407Hu5cYKcL1LDw////Riam5kbmlnqWhgYA "Jelly – Try It Online")**
### How?
```
%1×⁽¢Ẓd60 - Link 1, get hours and minutes portion of days: number (of days)
%1 - modulo by one - get the fractional part
⁽¢Ẓ - base 250 number = 1440 (that's 60*24)
× - multiply
d60 - divmod 60 (integer divide by sixty and yield result and remainder)
_“#ḟf’_.µd364Ad0¦7Ẏ;ÇḞ‘2¦ị3¦“TUWETHFRSASUMO”s2¤Ṛ€o0ẋ⁽¡Ḳḃ4¤¤U⁽œọ;“ṢṢ :‘¤Ọ¤żFḊ⁸Ṡ>-¤¡
- Main link: number, JulianDate -- breaking this down into parts...
_“#ḟf’_.µ - Main link part 1 (get the CMJD): number, JulianDate
“#ḟf’ - base 250 number = 2309103
_ - subtract from JulianDate
_. - subtract a half
µ - monadic chan separation, call that CMJD
d364Ad0¦7Ẏ;ÇḞ‘2¦ - Main link part 2 (get the numeric parts): number, CMJD
d364 - divmod 364 (integer divide by 364 and yield result and remainder)
A - absolute value (removes the sign from the year part)
¦ - sparse application:
0 - ...to index: zero (rightmost - the remainder)
d 7 - ...action: divmod 7 (integer divide by 7 and yield result and remainder)
Ẏ - tighten (to a list of three items)
Ç - call the last link (1) as a monad with argument CMJD
; - concatenate (now we have floats [abs(Y.0), W.0, D.0, H.0, M.x])
Ḟ - floor (vectorises) (yielding ints [abs(Y), W, D, H, M]
¦ - sparse application:
2 - ...to index: 2 (W)
‘ - ...action: increment (CD weeks are 1-indexed, W is 0 indexed)
ị3¦“TUWETHFRSASUMO”s2¤ - Main link part 3 (make the day-string): result of part 2
¦ - sparse application:
3 - ...to index: 3 (D)
ị - ...action: index into:
¤ - nilad followed by link(s) as a nilad:
“TUWETHFRSASUMO” - list of characters = "TUWETHFRSASUMO"
s2 - split into chunks of length two
- (note: D=0 yields "MO" due to 1-based & modular indexing)
Ṛ€o0ẋ⁽¡Ḳḃ4¤¤U - Main link part 4 (pad parts with zeros): result of part 3
Ṛ€ - reverse each (implicit decimal-list, so reverse of 289 is [9,8,2])
¤ - nilad followed by link(s) as a nilad:
0 - zero
¤ - nilad followed by link(s) as a nilad:
⁽¡Ḳ - base 250 number = 1178
ḃ4 - convert to bijective-base 4 = [4,2,1,2,2]
ẋ - repeat = [[0,0,0,0],[0,0],[0],[0,0],[0,0]]
o - logical or (vectorises) (yielding the reversed zero padded entries)
U - upend (reverse each - everything is already a list so not Ṛ€)
- now we have something like: [[Ya,Yb,Yc,Yd],[Wa,Wb],['Da','Db'],[ha,hb],[ma,mb]]
⁽œọ;“ṢṢ :‘¤Ọ¤ż - Main link part 5 (include the separators): result of part 4
¤ - nilad followed by link(s) as a nilad:
¤ - nilad followed by link(s) as a nilad:
⁽œọ - base 250 literal = 8722
“ṢṢ :‘ - code-page indices = [183,183,32,58]
; - concatenate = [8722,183,183,32,58]
Ọ - covert ordinals to characters = "−·· :"
ż - zip with the result from part 4, i.e. [['−',[Ya,Yb,Yc,Yd]],['·',[Wa,Wb]],['·',['Da','Db']],[' ',[ha,hb]],[':',[ma,mb]]]
FḊ⁸Ṡ>-¤¡ - Main link part 6 (remove the sign if need be): result from part 5
F - flatten the result from part 5 into a single list: ['−',Ya,Yb,Yc,Yd,'·',Wa,Wb,'·','Da','Db',' ',ha,hb,':',ma,mb]
¡ - repeat:
Ḋ - ...action: dequeue (remove first element)
¤ - ...number of times: nilad followed by link(s) as a nilad:
⁸ - chain's left argument = CMJD
Ṡ - sign (-1 if less than 0, 0 if equal to 0, 1 if greater than 0)
>- - greater than -1?
- implicit print
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 120 bytes
Despite being a language with built-in time formatting and string formatting, I still can't beat the Jelly answer...
```
->n{n-=2309103.5;Time.at((n%7+4)*86400).strftime('%04d·%02d·%%^a %%H:%%M'%[n/364,n%364/7+1]).sub(/. /,' ').tr ?-,?−}
```
[Try it online!](https://tio.run/##PY49DoIwGED3nqKDXwCF0j8LaNTVxc3Nv0AoaqKNgaIxxt3Zy7h7FC@CuLi85eUlr6yza1OMlk0wNjcTjLigCaOC9Ifz/VGT1LqugagnvW6sJKUeqWxZ2Fa5DlCZv19A@Y@wTjHAdAAwc2BhQqGkb6BlGPXYqs3qzA0JDn0HOx6xJZ4E/uTzeN6by25/0HirbYVOta1wsdDn9NDZrJA2efP/QX3KYs4RY3EiFEVcCqYiQaRKvg "Ruby – Try It Online")
] |
[Question]
[
This is a cops and robbers challenge - [Cop's Thread](https://codegolf.stackexchange.com/q/102056/48261)
Each of the cops have been tasked to write a program that terminates after exactly 60 seconds, or as close as possible. For example:
```
#include <unistd.h>
int main(int argc, char **argv){
sleep(60);
return 0;
}
```
Your goal is to take any of the uncracked submissions and change it so that it terminates after **31** seconds. If a cop's answer has been up for more than two weeks, it is immune to cracking. The original answer and your edit must have a [Levenshtein edit distance](http://planetcalc.com/1721/) of up to half of the original program's length.
The robber with the most cracks wins!
The cops have been allowed to do either of the following if they do not wish to use the system time calls:
* The speed of printing to `stdout` is controlled by the baud rate of the terminal you are printing to. If you wish, you can control the speed of your program by printing to `stdout` with a set baud rate. However, you must also cite an actual piece of hardware or terminal program that has that baud rate as default (e.g. a serial printer with a default print speed of 300 baud).
* If you are working in a language where all operations take some constant amount of time (such as assembly language), you can control the speed of your program by specifying the processor's clock rate. However, this too must be accompanied with a citation of an actual processor chip that runs at that speed (e.g. the 1 MHz 6502 put inside Apple //e and NES boards).
If you encounter a solution with this specification, you cannot change this parameter. (Not that it would help you much anyway, since it's hard to find an upgraded chip or serial output device with a 31:60 speed ratio).
[Answer]
# [Jelly](https://codegolf.stackexchange.com/a/102157/62131), edit distance 5 from 30 bytes
Original:
```
69266249554160949116534784œSÆl
```
Crack:
```
69266249554160949116534784œSÆl**\_29$$**
```
I just subtracted 29 from the timeout immediately before the `œS` runs. (`_29` subtracts 29, the dollars control precedence, a bit like parentheses in other languages.)
[Answer]
# [reticular](https://codegolf.stackexchange.com/a/102151/62131), edit distance 4 from 11 bytes
Original:
```
[[**3**w]5*]**4***;
```
Crack:
```
**6w**[[**1**w]5*]**5***;
```
The edit distance we've been given is just way too high to make cracking difficult. There was a lot of freedom in this one, so I aimed for one that preserved the spirit of the original code.
# [reticular](https://codegolf.stackexchange.com/a/102151/62131), edit distance 3 from 11 bytes
I found an improved crack, here it is:
Original:
```
[[3w]5*]**4***;
```
Crack:
```
**1w**[[3w]5*]**2***;
```
[Answer]
# [Pyth, 5 bytes, Maltysen](https://codegolf.stackexchange.com/a/102154/12012)
```
.dh*T3
```
`*T3` computes **30**, `h` increments, and `.d` waits for that many seconds.
] |
[Question]
[
Identify whether an IP address is internal, global, link-local, or reserved.
Input should be an IPv4 address in decimal octets separated by periods.
Output should be `0` for link-local (RFC 3927), `1` for internal (RFC 1918), `2` for global IPs (Internet), and `3` for otherwise reserved addresses.
All these address types are described in [RFC 5735](https://www.rfc-editor.org/rfc/rfc5735):
>
> 3. Global and Other Specialized Address Blocks
>
>
> 0.0.0.0/8 - Addresses in this block refer to source hosts on "this" network. Address 0.0.0.0/32 may be used as a source address for this
> host on this network; other addresses within 0.0.0.0/8 may be used to
> refer to specified hosts on this network ([RFC1122], Section
> 3.2.1.3).
>
>
> 10.0.0.0/8 - This block is set aside for use in private networks. Its intended use is documented in [RFC1918]. As described in that
>
> RFC, addresses within this block do not legitimately appear on the
>
> public Internet. These addresses can be used without any
>
> coordination with IANA or an Internet registry.
>
>
> 127.0.0.0/8 - This block is assigned for use as the Internet host loopback address. A datagram sent by a higher-level protocol to an
>
> address anywhere within this block loops back inside the host. This
>
> is ordinarily implemented using only 127.0.0.1/32 for loopback. As
>
> described in [RFC1122], Section 3.2.1.3, addresses within the entire
> 127.0.0.0/8 block do not legitimately appear on any network anywhere.
>
>
> 169.254.0.0/16 - This is the "link local" block. As described in [RFC3927], it is allocated for communication between hosts on a
>
> single link. Hosts obtain these addresses by auto-configuration,
>
> such as when a DHCP server cannot be found.
>
>
> 172.16.0.0/12 - This block is set aside for use in private networks. Its intended use is documented in [RFC1918]. As
> described in that RFC, addresses within this block do not
> legitimately appear on the public Internet. These addresses can be
> used without any coordination with IANA or an Internet registry.
>
>
> 192.0.0.0/24 - This block is reserved for IETF protocol assignments. At the time of writing this document, there are no
> current assignments. Allocation policy for future assignments is
> given in [RFC5736].
>
>
> 192.0.2.0/24 - This block is assigned as "TEST-NET-1" for use in documentation and example code. It is often used in conjunction with
> domain names example.com or example.net in vendor and protocol
>
> documentation. As described in [RFC5737], addresses within this
>
> block do not legitimately appear on the public Internet and can be
>
> used without any coordination with IANA or an Internet registry. See
> [RFC1166].
>
>
> 192.88.99.0/24 - This block is allocated for use as 6to4 relay anycast addresses, in [RFC3068]. In contrast with previously
>
> described blocks, packets destined to addresses from this block do
>
> appear in the public Internet. [RFC3068], Section 7, describes
>
> operational practices to prevent the malicious use of this block in
>
> routing protocols.
>
>
> 192.168.0.0/16 - This block is set aside for use in private networks. Its intended use is documented in [RFC1918]. As
> described in that RFC, addresses within this block do not
> legitimately appear on the public Internet. These addresses can be
> used without any coordination with IANA or an Internet registry.
>
>
> 198.18.0.0/15 - This block has been allocated for use in benchmark tests of network interconnect devices. [RFC2544] explains that this
>
> range was assigned to minimize the chance of conflict in case a
>
> testing device were to be accidentally connected to part of the
>
> Internet. Packets with source addresses from this range are not
>
> meant to be forwarded across the Internet.
>
>
> 198.51.100.0/24 - This block is assigned as "TEST-NET-2" for use in documentation and example code. It is often used in conjunction with
> domain names example.com or example.net in vendor and protocol
>
> documentation. As described in [RFC5737], addresses within this
>
> block do not legitimately appear on the public Internet and can be
>
> used without any coordination with IANA or an Internet registry.
>
>
> 203.0.113.0/24 - This block is assigned as "TEST-NET-3" for use in documentation and example code. It is often used in conjunction with
> domain names example.com or example.net in vendor and protocol
>
> documentation. As described in [RFC5737], addresses within this
>
> block do not legitimately appear on the public Internet and can be
>
> used without any coordination with IANA or an Internet registry.
>
>
> 224.0.0.0/4 - This block, formerly known as the Class D address space, is allocated for use in IPv4 multicast address assignments.
>
> The IANA guidelines for assignments from this space are described in
>
> [RFC3171].
>
>
> 240.0.0.0/4 - This block, formerly known as the Class E address space, is reserved for future use; see [RFC1112], Section 4.
>
>
> The one exception to this is the "limited broadcast" destination
>
> address 255.255.255.255. As described in [RFC0919] and [RFC0922],
>
> packets with this destination address are not forwarded at the IP
>
> layer.
>
>
> 4. Summary Table
>
>
>
> ```
> Address Block Present Use Reference
> 0.0.0.0/8 "This" Network RFC 1122, Section 3.2.1.3
> 10.0.0.0/8 Private-Use Networks RFC 1918
> 127.0.0.0/8 Loopback RFC 1122, Section 3.2.1.3
> 169.254.0.0/16 Link Local RFC 3927
> 172.16.0.0/12 Private-Use Networks RFC 1918
> 192.0.0.0/24 IETF Protocol Assignments RFC 5736
> 192.0.2.0/24 TEST-NET-1 RFC 5737
> 192.88.99.0/24 6to4 Relay Anycast RFC 3068
> 192.168.0.0/16 Private-Use Networks RFC 1918
> 198.18.0.0/15 Network Interconnect
> Device Benchmark Testing RFC 2544
> 198.51.100.0/24 TEST-NET-2 RFC 5737
> 203.0.113.0/24 TEST-NET-3 RFC 5737
> 224.0.0.0/4 Multicast RFC 3171
> 240.0.0.0/4 Reserved for Future Use RFC 1112, Section 4
> 255.255.255.255/32 Limited Broadcast RFC 919, Section 7
> RFC 922, Section 7
>
> ```
>
>
## Rules
* Standard loopholes apply.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest answer wins.
[Answer]
# JavaScript, ~~261~~ 207 bytes
```
v=>["169.254","10.|172.1[6789].|172.2\\d.|172.3[01]|192.168","x","0.|127|192.0.[02].|192.88.99|198.1[89].|198.51.100|203.0.113|2[345]\\d|22[^0123]"].reduce((a,x,i)=>v.search(x.replace(/\./g,"\\."))==0?i:a,2)
```
Readable version
```
v=>[
"169.254",
"10.|172.1[6789].|172.2\\d.|172.3[01]|192.168",
"x",
"0.|127|192.0.[02].|192.88.99|198.1[89].|198.51.100|203.0.113|2[345]\\d|22[^0123]"]
.reduce((a,x,i)=>v.search(x.replace(/\./g,"\\."))==0?i:a,2)
```
Create an array with matching patterns, loop through the patterns and compare to input. Return 0,1,2,3 as appropriate.
Edit: Fix bugs and streamline
[Answer]
# ES6 (Javascript), ~~204~~, ~~200~~, ~~182~~, 178 bytes
*EDIT*: Rewritten hex padding code, removed extra parenthesis, -4 bytes
*EDIT*: RegExp cleanup, streamline the result extraction, shorten the hex conversion code
*EDIT*: Refactored result extraction to bring it down to 200 bytes
Note, this should be pretty easy to shorten even further, by compressing the *RegExp* (as I never really bothered to do this)
**Golfed**
```
a=>/(^(?:00|7f|c0(?:5863|0{3}[02])|c6(?:1[23]|3364)|cb0071|e|f))|(^a9fe)|(^0a|^ac1|^c0a8)|./.exec(a.replace(/\d+./g,o=>(o|256).toString(16).slice(1))).reverse().findIndex(a=>a)^1
```
**Explanation**
*IP addresses* are shorter to write and easier to match, when converted to hexadecimal form, as CIDR masks tend to end on the 4 bit boundaries (with an exception of 198.18.0.0/15).
E.g.
```
0A000000-0AFFFFFF //10.0.0.0/8
AC100000-AC1FFFFF //172.16.0.0/12
C0A80000-C0A8FFFF //192.168.0.0/16
```
can be matched as
```
/^0a|^ac1|^c0a8/
```
**Test**
```
I=a=>/(^(?:00|7f|c0(?:5863|0{3}[02])|c6(?:1[23]|3364)|cb0071|e|f))|(^a9fe)|(^0a|^ac1|^c0a8)|./.exec(a.replace(/\d+./g,o=>(o|256).toString(16).slice(1))).reverse().findIndex(a=>a)^1;
T=(i,o)=>{
block=I(i);
console.log(i,(block==o)?"OK":"NOT OK");
}
T("0.0.0.0",3)
T("10.0.0.0",1)
T("11.0.0.0",2)
T("127.0.0.0",3)
T("169.254.0.0",0)
T("169.253.0.0",2)
T("172.16.0.0",1)
T("172.31.0.0",1)
T("172.32.0.0",2)
T("192.0.0.0",3)
T("192.0.2.0",3)
T("192.88.99.0",3)
T("192.168.0.0",1)
T("192.167.0.0",2)
T("198.18.0.0",3)
T("198.51.100.0",3)
T("203.0.113.0",3)
T("224.0.0.0",3)
T("239.255.255.255",3)
T("240.0.0.0",3)
T("255.255.255.255",3)
T("241.0.0.1",3)
T("151.101.192.71",2)
```
[Answer]
## Batch, 356 bytes
```
@echo off
set s=%1
if not %s==%s:.=% %0 %s:.= %
if %1.%2==169.254 exit/b0
if %1==10 exit/b1
if %1.%2==172.16 if %3 lss 32 exit/b1
if %1.%2==192.168 exit/b1
if %1==0 exit/b3
if %1==127 exit/b3
if %1 geq 224 exit/b3
for %%a in (18 19)do if %1.%2==192.%a exit/b3
for %%a in (192.0.0 192.0.2 198.51.100 203.0.113)do if %1.%2.%3==%%a exit/b3
exit/b2
```
Takes input as a command-line parameter and returns the result by setting the errorlevel.
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/87039/edit).
Closed 7 years ago.
[Improve this question](/posts/87039/edit)
# Origins
**tl;dw (too lazy, didn't write):** thought of it right before I fell asleep
# Challenge
**Breaking** a number is defined as the following steps:
* Take a number or a parseable data type as input in any allowed way.
* Duplicate the first digit (64 -> 664)
* Subtract 4 from the last digit (664 -> 660)
* If the subtraction gets a negative last digit, move the negative sign (-) to the front of the number (73 -> 773 -> -771)
* If the original number was negative, and the last digit becomes negative, remove all negative signs entirely. (-44441 -> 444443)
* Output the number in any allowed way.
Here are a few test cases:
```
64 -> 660
73 -> -771
thisisnotanumber -> (handle the situation)
432188 -> 4432184
-83213 -> 883211 (two negative signs turn into a positive)
0 -> -4 (0 -> 00 -> 0-4 -> -04 -> -4)
```
# Clarifications
[Standard loopholes are disallowed.](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default/1070#1070 "Standard loopholes are disallowed.")
By "parseable data type", I mean any data type (String, Float, etc) that can be converted into the number type your program/function uses (Integer, Number, etc).
Your answer can be a function or a program. In both cases, provide an explanation of the code.
If it is a function, give a usage of it.
Test cases (or online interpreter) would be a nice plus to your answer.
Preceding 0s (-04) aren't allowed.
Behavior should be exactly replicated from the test cases above.
[Answer]
## Batch, 105 bytes
```
@set/an=%1,n*=s=n^>^>31^|1
@set n=%n:~0,1%%n%
@cmd/cset/ad=n%%10,e=d-4,t=e^^^>^^^>31^^^|1,(n-d+e*t)*s*t
```
Alternatively the first line can be `@set/as=%1^>^>31^|1,n=%1*s`, also for 105 bytes. Explanation (without quoting metacharacters):
```
set /a n = %1 Get parameter
set /a s = n >> 31 | 1 Get sign of parameter
set /a n *= s Get absolute value of parameter
set n=%n:~0,1%%n% Duplicate the first digit
cmd /c Cause the final result to be printed
set /a d = n % 10 Get last digit
set /a e = d - 4 Calculate new last digit
set /a t = e >> 31 | 1 Get sign of new last digit
set /a e *= t Get absolute value of new last digit
set /a (n - d + e) * s * t Replace last digit and correct sign of result
```
[Answer]
# Ruby, ~~88~~ 87 + 3 (`-n` flag) = 90 bytes
Regex approach that reads lines from STDIN. Probably better solved with Perl if it's just regex like this?
Returns a nonsense `NoMethodError` if the input is not a number, which costs 14 bytes. If there's no need to worry about invalid inputs like that (the spec implied it needed handling) then the first line of the code can be removed.
*-2 bytes from @Dada*
```
+(~/^-?\d+$/)
sub(/\d/){$&*2}
sub(/.$/){$&.to_i-4}
p sub(/(-)?(.+)-/){$1?$2:?-+$2}.to_i
```
[Answer]
# Pyth, 31 bytes
```
*i++hJja0QTPJa0K-eJ4T^_1x<K0<Q0
```
Naive implementation of the question.
[Test suite.](http://pyth.herokuapp.com/?code=%2ai%2B%2BhJja0QTPJa0K-eJ4T%5E_1x%3CK0%3CQ0&test_suite=1&test_suite_input=64%0A73%0Athisisnotanumber%0A432188%0A-83213%0A0&debug=0)
[Answer]
# Python, ~~79~~ 78 Bytes
```
lambda x:"+-"[(int(x)<0)!=(int(x[-1])-4<0)]+x[1]+x[1:-1]+str(int(x[-1])-4)[-1]
```
anonymous lambda function, does all of the four parts, then adds them together. Expects input as a string with explicit sign e.g. "+64", output is of the same form. Throws ValueError if the string cannot be converted to an int.
[Answer]
# C, 191 bytes
```
f(char*n){if(!isdigit(*n)&!isdigit(n[1]))return 0;char*m;strcpy(m+1,n);*m=m[1];if(*n==45)m[1]=m[2];int a=strlen(n);if(m[a]<52)m[a]=100-m[a],m--,*m=45;else m[a]-=4;return atoi(m[1]^45?m:m+2);}
```
Ungolfed with explanations:
```
f(char*n){
if(!isdigit(*n)&!isdigit(n[1])) /* if first two chars aren't digits
* if it was only the first one, negative numbers wouldn't pass
* if it was only the second one, 0 wouldn't pass */
return 0; // handling
char*m;
strcpy(m+1,n); // copy leaving space for doubling the number
*m=m[1]; // double the first digit or the minus sign
if(*n==45) // if negative
m[1]=m[2]; // double the first digit
int a=strlen(n); /* length of the nunber
* it doesn't let me save 2 bytes, i dunno why. */
if(m[a]<52) // if the last digit is less than 4
m[a]=100-m[a], // subtract 4
m--, // leave space for minus sign
*m=45; // put minus sign
else
m[a]-=4; // subtract 4 from the last digit
return atoi(m[1]^45?m:m+2); /* if there are two minus signs, skip them,
* turn the string into an integer, and return */
}
```
] |
[Question]
[
**This question already has answers here**:
[Find the Nth pair of twin primes](/questions/31822/find-the-nth-pair-of-twin-primes)
(27 answers)
Closed 7 years ago.
# Introduction
We define **twin primes** as two natural numbers `p,p+2` which both are prime.
***Example***: `5` and `7` are twin primes.
Let's define the *twin number* of some set of numbers as the number of twin prime numbers in that set
***Example***: {`6`,`7`,`11`,`13`,`18`,`29`,`31`} has a twin number `4`, since there are four twin primes; `11,13` and `29,31`.
# Program
**Input**: A number `n`
**Output**: The twin number of the set of all **natural** numbers below `n`
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so lowest bytes wins.
[Answer]
# [MATL](http://esolangs.org/wiki/MATL), 7 bytes
```
qZqd2=s
```
This solution exploits the fact that the [prime gap](https://en.wikipedia.org/wiki/Prime_gap) (the difference between successsive prime numbers) is always >= 2 (with the exception being the gap between 2 and 3). Because of this fact, all *twin primes* will be successive prime numbers. In this solution we just compute the differences between all primes less than the input `n` and count how many of these differences are equal to 2.
[**Try it Online**](http://matl.tryitonline.net/#code=cVpxZDI9cw&input=MzI)
**Explanation**
```
% Implicitly grab input, N
q % Subtract one from the input (N-1)
Zq % Get an array of all primes <= (N-1)
d % Compute successive differences (prime gaps)
2= % Create a boolean array indicating which prime gaps are equal to 2
s % Count the TRUE values in this array to determine the twin number
% Implicitly display the result
```
If you instead want the *not* the number of pairs but the number of primes that are *part of a pair*, the following would work
```
qZqt!-|H=az
```
[**Try it Online**](http://matl.tryitonline.net/#code=cVpxdCEtfEg9YXo&input=MzI)
[Answer]
# Jolf, 10 bytes
```
ZlZd~Bx©{2
```
[Try it here!](http://conorobrien-foxx.github.io/Jolf/#code=WmxaZH5CeMKpezI)
## Explanation
```
ZlZd~Bx©{2
~B all numbers satisfying
©{ the prime condition ("the prime directive"?)
x below x
Zd (the differences between indices)
Zl 2 count the number of 2's
```
[Answer]
# Ruby, 43 + 8 (`-rprime` flag) = 51 bytes
```
->n{Prime.each(n-1).count{|i|(i-2).prime?}}
```
[Answer]
# [Perl 6](http://perl6.org), ~~54~~ 53 bytes
```
~~{2\*(3..$\_).rotor(3=>-1).grep: {all .[0,2]».is-prime}}~~
{2*(3,5...$_).rotor(2=>-1).grep: {all $_».is-prime}}
```
### Explanation:
```
{
2
*
(3,5...$_) # odd numbers
.rotor( 2 => -1 ) # grab 2 then backup one, repeat
.grep: # find all that match the following
{
# create a Junction object of the following
all
# call .is-prime on both elements of the
# list given to this inner block
$_».is-prime
}
}
```
] |
[Question]
[
A shape's volume is the measure of how much three-dimensional space that shape occupies.
# Challenge
Given six integers: `[L,W,H]` as length, width and height of one container and `[l,w,h]` as length, width and height of some random item.
You will need to calculate how many items would fit completely if the item was a liquid/fluid... and subtract how many items would also fit completely if the item was solid.
Note: Rotating the solid shape to fit empty space is required.
The input can be read from stdin, taken from args, can also be one or two lists/arrays, or any other valid way, but you can take in only six integers.
And the output should be one integer number: the difference.
Whole program or function are accepted.
Since this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") shortest code in bytes wins!
# Sample Input/Output
```
1) L=3 W=2 H=2 l=1 w=1 h=2
-> for item as liquid : 6 items fit completely
-> for item as solid : 6 items fit completely
output: 0
2) L=1 W=8 H=3 l=3 w=4 h=2
-> for item as liquid : 1 item fit completely
-> for item as solid : no items fit completely
output: 1
3) L=3 W=4 H=3 l=2 w=2 h=2
-> for item as liquid : 4 items fit completely
-> for item as solid : 2 items fit completely
output: 2
4) L=6 W=6 H=6 l=1 w=5 h=6
-> for item as liquid : 7 items fit completely
-> for item as solid : 7 items fit completely
output: 0
```
# Draws
Just for illustration of how the solid items could fit:
### Sample #3
[](https://i.stack.imgur.com/UKbdQ.png)
### Sample #4
[](https://i.stack.imgur.com/OitQr.png)
[Answer]
## Python 2.7 - 659 548 373 355 bytes
My first golf, but still very golfable.
The rotation thing didn't make it as easy as expected though.
```
import numpy as n
L,W,H,l,w,h=input();bx=n.zeros((L,W,H));s=0
q=(L*W*H)//(l*w*h);o=[[l,w,h],[l,h,w],[w,l,h],[w,h,l],[h,l,w],[h,w,l]];p=n.ndindex
for i in range(q):
for a,b,c in p(L,W,H):
for k in o:
d=n.copy(bx)
try:
for x,y,z in p(k[0],k[1],k[2]):
if d[a+x][b+y][c+z]:raise
d[a+x][b+y][c+z]=1
s+=1;bx=d
except:pass
print q-s
```
But still a nice little brainteaser :D
\*\*Edit: My colleague and I pondered a little more, and we found some more optimization potential
\*\*Saved 18 byte thanks to CatsAreFluffy
Examples:
```
[6,6,6,1,5,6]
0
[3,4,3,2,2,2]
2
```
] |
[Question]
[
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/74161/edit).
Closed 7 years ago.
[Improve this question](/posts/74161/edit)
A struggling manufacturer named **Tennessee Instrumental** is desperate to get into the calculator business. Problem is, they don't have any software engineers on payroll, and the deadline is *coming up fast*.
It's your job to help **TI** configure a basic calculus-ready calculator that can simplify expressions input as strings, and as a bonus (since they're on such a tight schedule), they don't care what language you use to get there! They do, however, care about how much space you take up. Not very good with hardware, it seems. Keep it brief, **fewest bytes** gets you hired.
# Goal
### Create a function which can simplify a basic calculus expression
Your calculator must be able to perform the following operations:
* `+` Addition
* `-` Subtraction and Negation
* `*` Multiplication
* `/` Division
* `^` Exponentiation
* `()` Parenthetical Reduction
* `()'` [Derivation](https://en.wikipedia.org/wiki/Derivative) (first order)
Your calculator must also be able to use **x** as a placeholder variable. **Do not solve for x.** That will come in time.
# Input
Input is a **string** containing the plaintext version of the expression you're looking to simplify. The only valid input characters are `0-9`, `x`, `+`, `-`, `*`, `/`, `^`, `()`, `'`, and . Some examples of valid inputs are listed below:
```
"1"
"5 + 8"
"(5x + 3)(4x + 2)"
"4x - 9x + 15"
"24x / 6"
"5x^2 + 14x - 3" // Use ^ for exponentiation
"(20x^2)'" // Use ()' for derivation
```
# Output
Output is a **string** containing the plaintext version of the expression after simplification.
The only acceptable operators left over are `+`, `-`, `/`, and `^`. Multiples of variables should be indicated as `2x`, `-5x`, etc. Fractions should be reduced as far as possible, and parentheses and derivations must be completely eliminated, with the exception of cases such as `ln(x)` which syntactically cannot be made to make sense without them.
The input examples from above should output as follows:
```
"1" => "1"
"5 + 8" => "13"
"(5x + 3)(4x + 2)" => "20x^2 + 22x + 6"
"4x - 9x + 15" => "-5x + 15"
"24x / 6" => "4x"
"5x^2 + 14x - 3" => "5x^2 + 14x - 3"
"(20x^2)'" => "40x"
```
Last but not least, if a derivation function exists in your language, **you may not use it**. Derivations must be done as manually as possible. Whitespace around the basic four operators and lack of whitespace around `^` and within `()` is preferred.
[Answer]
# Mathematica, 159 Bytes
```
ToString@Expand@ToExpression[StringReplace[#,"("~~a__~~")'"->"d["~~ a ~~"]"]<>"//.{d[a_ x^n->a n x^(n-1),d[x]->1,d[a__]/;a~FreeQ~x->0,d[a__+b__]->d[a]+d[b]}"]&
```
NOTE: While this works on all the examples it won't currently work on all sensible differentiable input because it doesn't balance brackets when looking for derivatives. I'll change this once I've had the time to think of a sufficiently concise way of doing it. I'm sure there's some other stuff that goes wrong too, so please let me know if you spot something! There are a few bytes that are easily golfed off too, I'll get to those..
] |
[Question]
[
Output the provided table of English pronouns exactly, in as few bytes as possible.
### Code rules
* The code will take no input
* The table is tab-delimited
* Each line begins with a single tab `\t` if there is no row heading
* Each line ends in a single newline `\n` (not `\r\n`), including the last line
* There are four tabs between "Plural" and the newline (`Plural\t\t\t\t\n`) because it refers to the next four columns as well, but no other line has trailing tabs or spaces
### Spelling rules
* There is no Possessive Pronoun for "it", so the data is "-"
* The only pronoun to use an apostrophe is "one's". "It's" means "it is" or "is has" and is a contraction, not a pronoun
* Some people use "themself" for the singular, gender non-specific, third person, but in this table it is "themselves"
* This table is not complete; other non-standard, alternate and rare forms are not included
### Output
Use [this link](https://jsfiddle.net/yvurtL85/1/embedded/result/) to check your output.
### Pretty-printed (do not output this!)
```
Singular Plural
Possessive Possessive Possessive Possessive
Subject Object Determiner Pronoun Reflexive Subject Object Determiner Pronoun Reflexive
First Person I me my mine myself we us our ours ourselves
Second Person you you your yours yourself you you your yours yourselves
Third Person he him his his himself they them their theirs themselves
she her her hers herself
it it its - itself
one one one's one's oneself
they them their theirs themselves
```
[Answer]
## [Bubblegum](http://esolangs.org/wiki/Bubblegum), 191 bytes
Hexdump (reversible with `xxd -r`), as source code contains unprintables:
```
00000000: a58f 3d0e c230 0c85 67e7 146c 4cdc 0221 ..=..0..g..lL..!
00000010: 3151 512e 508a 4b83 f223 d949 a1b7 274e 1QQ.P.K..#.I..'N
00000020: 5260 410c 4479 9fa3 67f9 4586 56bb 6b34 R`A.Dy..g.E.V.k4
00000030: 1d81 9cc6 44ea 8cbc 14b4 f17c c33e c0a1 ....D......|.>..
00000040: 94c6 3323 b39e 70b5 c580 64b5 43fa 741b ..3#..p...d.C.t.
00000050: f2ce 4707 471c 0c3e 92f3 7f82 da69 e2b0 ..G.G..>.....i..
00000060: 6a90 d83b d883 45b0 33c8 5caa 8c66 803b j..;..E.3.\..f.;
00000070: 4264 f091 44f9 91ec 0959 b5d8 7b77 5946 Bd..D....Y..{wYF
00000080: 671f 1751 0617 4ac4 f79e e49c 464d af98 g..Q..J.....FM..
00000090: 1161 d436 89ab 6c4e 0823 ce02 2bd0 54c8 .a.6..lN.#..+.T.
000000a0: d9a9 29c0 329a b6ad e28c 34ab 4087 7219 ..)[[email protected]](/cdn-cgi/l/email-protection).
000000b0: 36c2 ecf9 b460 d59a df2c cddf bf3d 01 6....`...,...=.
```
Look, *someone* had to do it...
] |
[Question]
[
[The Sylvester-Gallai theorem](//en.wikipedia.org/wiki/Sylvester-Gallai_theorem) says: Suppose you have a finite list of points in the plane. Suppose further that not all of those points are collinear (lie in a single line). Then there is some line containing precisely two of the points. (That is, there's some line on which two of the points lie, but not more than two.)
You task is to find such a line. Note that more than one exists; you need to find one.
## Input:
A bunch of points denoted by their Cartesian coordinates. You may assume the coordinates are nonnegative integers, if you like. The string `(1,2),(0,4),(5,6)` and the list `1`, `2`, `0`, `4`, `5`, `6` and other formats are fine, and can be function parameters or read from STDIN or whatever.
If you prefer, allow also radical-root input (with positive-integer index). Then, each point will be represented by four numbers: the index and radicand of the abscissa, and the index and radicand of the ordinate. A rational number will be represented with index `1`. Again, the input can be like `((1,2),(3,4)),((6,7),(8,9)),((2,3),(4,5))` or like `1`, `2`, `3`, `4`, `6`, `7`, `8`, `9`, `2`, `3`, `4`, `5`, or what-have-you. You may assume that the radicand is a nonnegative integer.
You may assume the points are distinct from one another and are not all collinear (and thus, in particular, that there are more than two points).
## Output:
A line guaranteed by Sylvester-Gallai. This can be presented in any Cartesian-based form that completely specifies the line and allows people to visualize it. (I expect that answers will typically use either the line's slope and a point on it or two points on the line.)
## Scoring:
This is a popularity contest. The answer with the greatest number of net votes after about a week will get the checkmark. Everyone can vote at will, obviously, but I, personally, will bear in mind at least these factors: ingenuity of the solution (including avoidance of the brute-force method), explanation of the code, ability to accept radical-root input, and simplicity of the code (in flop count / runtime).
[Answer]
## Python 2, not golfed
Sure, they say there's a worst case O(n\*log(n)) algorithm, but who cares about the worst case? It's the average case we usually care about, and this simple random algorithm runs in expected linear time on arbitrary inputs!
(By comparison, the deterministic brute force algorithm can be fed carefully constructed inputs to force it to run in quadratic time at least.)
```
import random,math
def radical_to_normal(x,y): return (x[1]**(1./x[0]),y[1]**(1./y[0]))
def distance_to_line(p1,p2,p3):
dx = p2[0] - p1[0]
dy = p2[1] - p1[1]
return abs(dy*p3[0] + dx*p3[1] + p2[0]*p1[1] - p2[1]*p1[0]) / math.sqrt(dy*dy + dx*dx)
points = input() #input as list of pairs
c = True
while c:
c = False
p1,p2 = random.sample(set(points), 2)
for p3 in points:
if distance_to_line(radical_to_normal(*p1), radical_to_normal(*p2), radical_to_normal(*p3)) < 0.00001:
c = True
print p1,p2
```
Example run:
```
➤ python sylvester.py
[((1,0),(1,0)),((1,1),(1,0)),((1,2),(1,0)),((1,0),(1,1)),((1,1),(1,1)),((1,2),(1,1)),((1,0),(1,2)),((1,1),(1,2)),((1,2),(1,2))]
((1, 2), (1, 2)) ((1, 0), (1, 1))
```
## How it works
It's been proved (Csima and Sawyer 1993) that roughly 6/13 of all lines in any set are ordinary (only involve 2 points from the set) except when n=7. As the number of points goes to infinity, the lower bound goes to 1/2 of the lines (Green and Tao 2013). Therefore, we expect to have to test around 2-3 pairs of points on average before finding an ordinary line *if* we sample pairs of points at random.
This simple program just selects a random pair of points, then checks the distance from the line they form to a third point, which ranges over all points in the set. All three points are converted from radical root form to floats by `radical_to_normal()` before the distance is calculated by `distance_to_line()`. If the distance is below a threshold (indicating they are collinear), we set a sentinel to try again. Until every point tested passes above the threshold, we try, try again. (This threshold could be made much smaller and still work, of course.)
Since we test an expected constant number of point pairs, and we test n points for each pair, the algorithm runs in expected time O(n).
[Answer]
# Mathematica, 73 bytes
```
Cases[#~Subsets~{2},p_/;InfiniteLine@p~RegionMember~#~Count~True==2,1,1]&
```
---
**Test Case:**
```
%[{{0,0},{1,1},{3,2},{3,3},{6,4},{4,5}}]
(* {{{0,0},{4,5}}} *)
```
---
**Explanations:**
`#~Subsets~{2}` gives all pairs of points; `InfiniteLine@p~RegionMember~#~Count~True==2` tests whether there are exactly two points intersect the infinite line given by a pair of points `p`; `Cases[..., ..., 1, 1]` gives the first pair of points that meet the condition.
Mathematica naturally accepts numbers like `3/5`, `Pi`, `Sqrt[2]`, etc, and gives accurate results as long as the inputs are accurate.
] |
Subsets and Splits