text
stringlengths 180
608k
|
|---|
[Question]
[
Your goal is to create a function or a program to reverse the bits in a range of integers given an integer \$n\$. In other words, you want to find the [bit-reversal permutation](https://en.wikipedia.org/wiki/Bit-reversal_permutation) of a range of \$2^n\$ items, zero-indexed. This is also the OEIS sequence [A030109](https://oeis.org/A030109). This process is often used in computing Fast Fourier Transforms, such as the in-place Cooley-Tukey algorithm for FFT. There is also a [challenge](https://codegolf.stackexchange.com/questions/12420/too-fast-too-fourier-fft-code-golf) for computing the FFT for sequences where the length is a power of 2.
This process requires you to iterate over the range \$[0, 2^n-1]\$, convert each value to binary and reverse the bits in that value. You will be treating each value as a \$n\$-digit number in base 2 which means reversal will only occur among the last \$n\$ bits.
For example, if \$n = 3\$, the range of integers is `[0, 1, 2, 3, 4, 5, 6, 7]`. These are
```
i Regular Bit-Reversed j
0 000 000 0
1 001 100 4
2 010 010 2
3 011 110 6
4 100 001 1
5 101 101 5
6 110 011 3
7 111 111 7
```
where each index \$i\$ is converted to an index \$j\$ using bit-reversal. This means that the output is `[0, 4, 2, 6, 1, 5, 3, 7]`.
The output for \$n\$ from 0 thru 4 are
```
n Bit-Reversed Permutation
0 [0]
1 [0, 1]
2 [0, 2, 1, 3]
3 [0, 4, 2, 6, 1, 5, 3, 7]
```
You may have noticed a pattern forming. Given \$n\$, you can take the previous sequence for \$n-1\$ and double it. Then concatenate that doubled list to the same double list but incremented by one. To show,
```
[0, 2, 1, 3] * 2 = [0, 4, 2, 6]
[0, 4, 2, 6] + 1 = [1, 5, 3, 7]
[0, 4, 2, 6] ⊕ [1, 5, 3, 7] = [0, 4, 2, 6, 1, 5, 3, 7]
```
where \$⊕\$ represents concatenation.
You can use either of the two methods above in order to form your solution. If you know a better way, you are free to use that too. Any method is fine as long as it outputs the correct results.
## Rules
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest solution wins.
* Builtins that solve this challenge as a whole and builtins that compute the bit-reversal of a value are not allowed. This does not include builtins which perform binary conversion or other bitwise operations.
* Your solution must be, at the least, valid for \$n\$ from 0 to 31.
[Answer]
# [Haskell](https://www.haskell.org/), ~~40~~ 37 bytes
```
f 0=[0]
f a=[(*2),(+1).(*2)]<*>f(a-1)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P03BwDbaIJYrTSHRNlpDy0hTR0PbUFMPxIq10bJL00jUNdT8n5uYmadgq5CbWOAbr6BRUJSZV6KXpqkQbahjpGOsYxL7HwA "Haskell – Try It Online")
Thanks to @Laikoni for three bytes!
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 8 bytes
Code:
```
¾)IF·D>«
```
Explanation:
```
¾ # Constant for 0.
) # Wrap it up into an array.
IF # Do the following input times.
· # Double every element.
D # Duplicate it.
> # Increment by 1.
« # Concatenate the first array.
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=wr4pSUbCt0Q-wqs&input=Mw).
[Answer]
# MATL, ~~13~~ ~~12~~ ~~10~~ ~~9~~ 8 bytes
```
0i:"EtQh
```
[**Try it Online**](http://matl.tryitonline.net/#code=MGk6IkV0UWg&input=Mw)
**Explanation**
```
0 % Push number literal 0 to the stack
i:" % Loop n times
E % Multiply by two
t % Duplicate
Q % Add one
h % Horizontally concatenate the result
% Implicit end of loop, and implicitly display the result
```
---
For the sake of completeness, here was my old answer using the non-recursive approach (9 bytes).
```
W:qB2&PXB
```
[**Try it Online**](http://matl.tryitonline.net/#code=VzpxQjImUFhC&input=Mw)
**Explanation**
```
W % Compute 2 to the power% ofImplicitly thegrab input (n) and compute 2^n
: % Create an array from [1...2^n]
q % Subtract 1 to get [0...(2^n - 1)]
B % Convert to binary where each row is the binary representation of a number
2&P % Flip this 2D array of binary numbers along the second dimension
XB % Convert binary back to decimal
% Implicitly display the result
```
[Answer]
# J, ~~15~~ 11 bytes
```
2&(*,1+*)0:
```
There is an alternative for **15 bytes** that uses straight-forward binary conversion and reversal.
```
2|."1&.#:@i.@^]
```
## Usage
```
f =: 2&(*,1+*)0:
f 0
0
f 1
0 1
f 2
0 2 1 3
f 3
0 4 2 6 1 5 3 7
f 4
0 8 4 12 2 10 6 14 1 9 5 13 3 11 7 15
```
## Explanation
```
2&(*,1+*)0: Input: n
0: The constant 0
2&( ) Repeat n times starting with x = [0]
2 * Multiply each in x by 2
1+ Add 1 to each
, Append that to
2 * The list formed by multiplying each in x by 2
Return that as the next value of x
Return the final value of x
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
2ṗ’UḄ
```
[Try it online!](https://tio.run/##y0rNyan8/9/o4c7pjxpmhj7c0fL//39jAA "Jelly – Try It Online")
-1 thanks to [Dennis](https://codegolf.stackexchange.com/users/12012/dennis).
[Answer]
# Octave, 37 bytes
```
@(n)bin2dec(fliplr(dec2bin(0:2^n-1)))
```
Creates an anonymous function named `ans` that can simply be called with `ans(n)`.
[**Online Demo**](http://ideone.com/1jopEJ)
[Answer]
# Python 2, ~~56~~ ~~55~~ 54 bytes
```
f=lambda n:[0][n:]or[i+j*2for i in 0,1for j in f(n-1)]
```
Test it on [Ideone](http://ideone.com/Smw0nC).
*Thanks to @xnor for golfing off 1 byte!*
[Answer]
# Java, ~~422~~ 419 bytes:
```
import java.util.*;class A{static int[]P(int n){int[]U=new int[(int)Math.pow(2,n)];for(int i=0;i<U.length;i++){String Q=new String(Integer.toBinaryString(i));if(Q.length()<n){Q=new String(new char[n-Q.length()]).replace("\0","0")+Q;}U[i]=Integer.parseInt(new StringBuilder(Q).reverse().toString(),2);}return U;}public static void main(String[]a){System.out.print(Arrays.toString(P(new Scanner(System.in).nextInt())));}}
```
Well, I finally learned Java for my second programming language, so I wanted to use my new skills to complete a simple challenge, and although it turned out *very* long, I am not disappointed. I am just glad I was able to complete a simple challenge in Java.
[Try It Online! (Ideone)](http://ideone.com/fy1xGj)
[Answer]
## Mathematica, ~~56~~ 33 bytes
Byte count assumes an ISO 8859-1 encoded source.
```
±0={0};±x_:=Join[y=±(x-1)2,y+1]
```
This uses the recursive definition to define a unary operator `±`.
[Answer]
# Perl, ~~46~~ 45 bytes
Includes +1 for `-p`
Give input number on STDIN
```
#!/usr/bin/perl -p
map$F[@F]=($_*=2)+1,@F for(@F=0)..$_;$_="@F"
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~7~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ḥ;‘$$¡
```
*Thanks to @EriktheOutgolfer for golfing off 1 byte!*
[Try it online!](https://tio.run/##y0rNyan8///hjiXWjxpmqKgcWvj/vzEA "Jelly – Try It Online")
### How it works
```
Ḥ;‘$$¡ Main link. No arguments.
Implicit argument / initial return value: 0
¡ Read an integer n from STDIN and call the link to the left n times.
$ Combine the two links to the left into a monadic chain, to be called
with argument A (initially 0, later an array).
Ḥ Unhalve; yield 2A.
$ Combine the two links to the left into a monadic chain, to be called
with argument 2A.
‘ Increment; yield 2A + 1
; Concatenate 2A and 2A + 1.
```
[Answer]
# Pyth - 11 bytes
```
ushMByMGQ]0
```
[Test Suite](http://pyth.herokuapp.com/?code=ushMByMGQ%5D0&test_suite=1&test_suite_input=0%0A1%0A2%0A3&debug=0).
[Answer]
# Javascript ES6, ~~65~~ ~~53~~ 51 bytes
```
f=(n,m=1)=>n?[...n=f(n-1,m+m),...n.map(i=>i+m)]:[0]
```
Uses the recursive double-increment-concat algorithm.
Example runs:
```
f(0) => [0]
f(1) => [0, 1]
f(2) => [0, 2, 1, 3]
f(4) => [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]
```
[Answer]
# Python 3, ~~67~~ 59 bytes
*Thanks to @Dennis for -8 bytes*
```
lambda n:[int(bin(i+2**n)[:1:-1],2)//2for i in range(2**n)]
```
We may as well have a (modified) straightforward implementation in Python, even if this is quite long.
An anonymous function that takes input by argument and returns the bit-reversed permutation as a list.
**How it works**
```
lambda n Anonymous function with input n
...for i in range(2**n) Range from 0 to 2**n-1
bin(i+2**n)[:1:-1] Convert i+2**n to binary string, giving 1 more digit than needed,
remove '0b' from start, and reverse
int(...,2) Convert back to decimal
...//2 The binary representation of the decimal value has one trailing
bit that is not required. This is removed by integer division by 2
:[...] Return as list
```
[Try it on Ideone](https://ideone.com/Atgesv)
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 12 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
Requires `⎕IO←0` which is default on many systems.
```
2⊥⊖2⊥⍣¯1⍳2*⎕
```
`2⊥` from-base-2 of
`⊖` the flipped
`2⊥⍣¯1` inverse of from-base-2 of
`⍳` the first *n* integers, where *n* is
`2*` 2 to the power of
`⎕` numeric input
[TryAPL online!](http://tryapl.org/?a=%u2395IO%u21900%20%u22C4%20%u2206%u21900%20%u22C4%202%u22A5%u22962%u22A5%u2363%AF1%u23732*%u2206%20%u22C4%20%u2206%u21901%20%u22C4%202%u22A5%u22962%u22A5%u2363%AF1%u23732*%u2206%20%u22C4%20%u2206%u21902%20%u22C4%202%u22A5%u22962%u22A5%u2363%AF1%u23732*%u2206%20%u22C4%20%u2206%u21903%20%u22C4%202%u22A5%u22962%u22A5%u2363%AF1%u23732*%u2206&run)
---
For comparison, here is the other method:
```
(2∘×,1+2∘×)⍣⎕⊢0
```
`(` the function train...
`2∘×` two times (the argument)
`,` concatenated to
`1+` one plus
`2∘×` two times (the argument)
`)⍣` applied as many times as specified by
`⎕` numeric input
`⊢` on
`0` zero
[Answer]
# [Ruby](https://www.ruby-lang.org/), 51 bytes
```
f=->n{n<1?[0]:(a=f[n-1].map{|i|i*2})+a.map(&:next)}
```
[Try it online!](https://tio.run/##KypNqvz/P81W1y6vOs/G0D7aINZKI9E2LTpP1zBWLzexoLomsyZTy6hWUzsRxNVQs8pLrSjRrP1voleSmZtarJCSrwBUwsVZUFpSrKCkXJ1Zq6Brp6BcnRadGVurxJWal/IfAA "Ruby – Try It Online")
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~11~~ 8 bytes
```
2/|!2|&:
```
[Try it online!](https://tio.run/##y9bNS8/7/z/Nyki/RtGoRs3qf5q6obai6X8A "K (ngn/k) – Try It Online")
```
x:3 / just for testing
&x / that many zeroes
0 0 0
2|&x / max with 2
2 2 2
!x#2 / binary words of length x, as a transposed matrix
(0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1)
|!x#2 / reverse
(0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1
0 0 0 0 1 1 1 1)
2/|!x#2 / base-2 decode the columns
0 4 2 6 1 5 3 7
```
`&` is the last verb in the composition so we need a `:` to force it to be monadic
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~57 47~~ 39 bytes
```
->n{[*0...2**n].sort_by{|a|a.digits 2}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOlrLQE9Pz0hLKy9Wrzi/qCQ@qbK6JrEmUS8lMz2zpFjBqLb2f4FCWrRRLBeIMoZQJrH/AQ "Ruby – Try It Online")
3 years later, 18 bytes golfed.
[Answer]
# Julia, ~~23~~ 22 bytes
```
!n=n>0&&[t=2*!~-n;t+1]
```
Rather straightforward implementation of the process described in the challenge spec.
[Try it online!](http://julia.tryitonline.net/#code=IW49bj4wJiZbdD0yKiF-LW47dCsxXQoKZm9yIG4gaW4gMDozCiAgICBAcHJpbnRmKCIlZCAtPiAlc1xuIiwgbiwgIW4pCmVuZA&input=)
[Answer]
# Pyth, 8 bytes
```
iR2_M^U2
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=iR2_M%5EU2&input=3&test_suite_input=0%0A1%0A2%0A3&debug=0) or [Test Suite](http://pyth.herokuapp.com/?code=iR2_M%5EU2&input=3&test_suite=1&test_suite_input=0%0A1%0A2%0A3&debug=0)
### Explanation:
```
iR2_M^U2Q implicit Q (=input number) at the end
^U2Q generate all lists of zeros and ones of length Q in order
_M reverse each list
iR2 convert each list to a number
```
[Answer]
## Clojure, 78 bytes
Just following the spec...
```
(defn f[n](if(= n 0)[0](let[F(map #(* 2 %)(f(dec n)))](concat F(map inc F)))))
```
[Answer]
# PHP, 57 bytes
```
while($i<1<<$argv[1])echo bindec(strrev(decbin($i++))),_;
```
takes input from command line parameter, prints underscore-delimited values. Run with `-nr`.
**recursive solution, 72 bytes**
```
function p($n){$r=[$n];if($n)foreach($r=p($n-1)as$q)$r[]=$q+1;return$r;}
```
function takes integer, returns array
[Answer]
## JavaScript (Firefox 30-57), 48 bytes
```
f=n=>n?[for(x of[0,1])for(y of f(n-1))x+y+y]:[0]
```
Port of @Dennis♦'s Python 2 solution.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~14~~ 13 bytes
```
2pU Ǥw ú0U Í
```
[Try it online!](https://ethproductions.github.io/japt/?v=2.0a0&code=MnBVIMekdyD6MFUgzQ==&input=LW1SClsxLCAyLCAzLCA0LCA1XQ==)
### Unpacked & How it works
```
2pU o_s2 w ú0U n2
2pU 2**n
o_ range(2**n).map(...)
s2 convert to binary string
w reverse
ú0U right-pad to length n, filling with '0'
n2 convert binary string to number
```
Straightforward implementation.
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 9 bytes
```
(⍋,⍨)⍣⎕⊢0
```
[Try it online!](https://tio.run/##HYw9CsJAEIX7PcV2o5DAbuIPWHiXJWEluBjZpBFJJxoTN9hYWqiNFxAh4GXmInGSYt68x/dm1Nb48U6ZdOVHRmVZEnXY3JIUj1fBsDzpboSu9tC9x@hehLB6io4AQ9dIvPyg0NTdgwcE@7GA7gNYVkS/lCMLGji6e25VrDf@koTl/Q318PywZDW6dgHpGrA@gFaJoR8tYVt0gudcMNkrlywYdsAlD1k4@AmlGeUpD/mc@X8 "APL (Dyalog Classic) – Try It Online")
`⎕` evaluated input
`(` `)⍣⎕⊢0` apply the thing in `(` `)` that many times, starting with `0`
`,⍨` concatenate the current result with itself
`⍋` indices of a sort-ascending permutation
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 25 bytes
```
{[X+] 0,|(0 X(2 X**^$_))}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/OjpCO1bBQKdGw0AhQsNIIUJLK04lXlOz9n9BaYlCmgaQbWenl5ZboqGuamBUoa6pkJZfpBBnYf0fAA "Perl 6 – Try It Online")
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 42 bytes
```
{0,{$^p+^($_-$_/2+>lsb ++$)}...$_}o 1+<*-1
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/2kCnWiWuQDtOQyVeVyVe30jbLqc4SUFbW0WzVk9PTyW@Nl/BUNtGS9fwvzVXQWmJQhpQoaadnV5abomGuqqBUYW6pkJafpFCnIX1fwA "Perl 6 – Try It Online")
Incrementing an integer simply flips a sequence of least-significant bits, for example from `xxxx0111` to `xxxx1000`. So the next bit-reversed index can be obtained from the previous one by flipping a sequence of most-significant bits. The XOR mask can be computed with `m - (m >> (ctz(i) + 1))` for `m = 2**n` or `m = 2**n-1`.
[Answer]
# TI-BASIC, 26 bytes
```
Input A:{0:For(I,1,A:2Ans:augment(Ans,1+Ans:End:Ans
```
Prompts the user to input *n*.
Outputs the bit-reversal permutation as is specified in the challenge.
**Explanation:**
```
Input A ;prompt the user for "n". store the input into A
{0 ;leave {0} in Ans
For(I,1,A ;loop A times
2Ans ;double Ans and leave the result in Ans
augment(Ans,1+Ans ;add 1 to Ans and append it to the previous result
; leave the new result in Ans
End ;loop end
Ans ;leave Ans in Ans
;implicit print of Ans
```
**Examples:**
```
prgmCDGF25
?1
{0 1}
prgmCDGF25
?3
{0 4 2 6 1 5 3 7}
```
**Note:** TI-BASIC is a tokenized language. Character count does *not* equal byte count.
[Answer]
# [Desmos](https://desmos.com/calculator), 71 bytes
```
f(n)=[total(mod(floor(2i/2^{[1...n]}),2)2^{[n-1...0]})fori=[0...2^n-1]]
```
Straightforward implementation of the challenge (convert to binary, then reverse), but probably optimizable with actions...
[Try It On Desmos!](https://www.desmos.com/calculator/icphgaiuxq)
[Try It On Desmos! - Prettified](https://www.desmos.com/calculator/thym4i9rks)
[Answer]
# [Factor](https://factorcode.org/), 43 bytes
```
[ { 0 } [ 2 v*n dup 1 v+n append ] repeat ]
```
[Try it online!](https://tio.run/##JcsxDoJAEEbhnlP8tRqCxkoPYGxsjNWGYoQRiTCMswOJGs@@amxfvnehygdLp@P@sNugJ7/mE/9SxI1NuEPk@8hScUTDwkZd@yRvB4lQY/eHWiv@P42k@bptlhVYI9DiXKaAFwq8EbDCNBPUo2KJaS4gVZYaJYyVyVGmnhR5@gA "Factor – Try It Online")
[Answer]
# x86, 31 bytes
Takes a sufficiently large `int[] buffer` in `eax` and *n* in `ecx`, and returns the buffer in `eax`.
Implements the concatenating algorithm given in the challenge statement. It may be possible to save bytes by incrementing the pointers by 4 instead of using array accesses directly, but `lea`/`mov` is already pretty short (3 bytes for 3 regs and a multiplier).
```
.section .text
.globl main
main:
mov $buf, %eax # buf addr
mov $3, %ecx # n
start:
xor %ebx, %ebx
mov %ebx, (%eax) # init buf[0] = 0
inc %ebx # x = 1
l1:
mov %ebx, %edi
dec %edi # i = x-1
lea (%eax,%ebx,4), %edx # buf+x
l2:
mov (%eax,%edi,4), %esi # z = buf[i]
sal %esi # z *= 2
mov %esi, (%eax,%edi,4) # buf[i] = z
inc %esi # z += 1
mov %esi, (%edx,%edi,4) # buf[x+i] = z
dec %edi # --i
jns l2 # do while (i >= 0)
sal %ebx # x *= 2
loop l1 # do while (--n)
ret
.data
buf: .space 256, -1
```
Hexdump:
```
00000507 31 db 89 18 43 89 df 4f 8d 14 98 8b 34 b8 d1 e6 |1...C..O....4...|
00000517 89 34 b8 46 89 34 ba 4f 79 f1 d1 e3 e2 e7 c3 |.4.F.4.Oy......|
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 5 years ago.
[Improve this question](/posts/163860/edit)
I would like to convert ASCII art to something that takes less bytes. I have string like this:
```
my $string = ' ██ ████ █';
```
And I would convert this to something like this:
```
print "█" x 1."█" x 1."█" x 1"█" x 1"█" x 1;
```
So I would write this in one line and convert to using `x` operator. How can achieve this?
]
|
[Question]
[
Given an input string, output that string with all vowels `a`, `e`, `i`, `o` and `u` swapped at random between each other.
For example, in the string `this is a test`, there are 4 vowels: `[i, i, a, e]`. A valid shuffling of those vowels could be `[a, i, e, i]` therefore yielding the output `thas is e tist`.
### About shuffling
All shuffles shall be equally likely **if we consider equal vowels to be distinct**. For the example above, those 24 shuffles are possible:
```
[i1, i2, a, e] [i1, i2, e, a] [i1, a, i2, e] [i1, a, e, i2]
[i1, e, i2, a] [i1, e, a, i2] [i2, i1, a, e] [i2, i1, e, a]
[i2, a, i1, e] [i2, a, e, i1] [i2, e, i1, a] [i2, e, a, i1]
[a, i1, i2, e] [a, i1, e, i2] [a, i2, i1, e] [a, i2, e, i1]
[a, e, i1, i2] [a, e, i2, i1] [e, i1, i2, a] [e, i1, a, i2]
[e, i2, i1, a] [e, i2, a, i1] [e, a, i1, i2] [e, a, i2, i1]
```
Each one should be equally as likely.
You may not try random shuffles of the entire string until finding one where all vowels are in the right place. In short, your code's running time shall be constant if the input is constant.
### Inputs and outputs
* You may assume that all letters in the input will be lowercase or uppercase. You may also support mixed casing, though this won't give you any bonus.
* The input will always consist of printable ASCII characters. All characters that are in the input shall be in the output, only the vowels must be shuffled around and nothing else.
* The input can be empty. There is no guarantee that the input will contain at least one vowel or at least one non-vowel.
* You may take the input from `STDIN`, as a function parameter, or anything similar.
* You may print the output to `STDOUT`, return it from a function, or anything similar.
### Test cases
The first line is the given input. The second line is one of the possible outputs.
```
<empty string>
<empty string>
a
a
cwm
cwm
the quick brown fox jumps over the lazy dog.
tho qeuck brewn fax jumps ovir the lozy dog.
abcdefghijklmnopqrstuvwxyz
abcdefghujklmnipqrstovwxyz
programming puzzles & code golf
pregromming pezzlos & coda gulf
fatalize
fitaleza
martin ender
mirten ander
```
### Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), *sa tho shirtist enswer en bytes wons*.
[Answer]
## R, 92 91
Can't comment yet so I'm adding my own answer albeit very similar to @Andreï Kostyrka answer (believe it or not but came up with it independently).
```
s=strsplit(readline(),"")[[1]];v=s%in%c("a","e","i","o","u");s[v]=sample(s[v]);cat(s,sep="")
```
### Ungolfed
```
s=strsplit(readline(),"")[[1]] # Read input and store as a vector
v=s%in%c("a","e","i","o","u") # Return TRUE/FALSE vector if vowel
s[v]=sample(s[v]) # Replace vector if TRUE with a random permutation of vowels
cat(s,sep="") # Print concatenated vector
```
---
Saved one byte thanks to @Vlo
```
s=strsplit(readline(),"")[[1]];s[v]=sample(s[v<-s%in%c("a","e","i","o","u")]);cat(s,sep="")
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
f€“¡ẎṢɱ»ðœpżFẊ¥
```
[Try it online!](http://jelly.tryitonline.net/#code=ZuKCrOKAnMKh4bqO4bmiybHCu8OwxZNwxbxG4bqKwqU&input=&args=dGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4)
### How it works
```
f€“¡ẎṢɱ»ðœpżFẊ¥ Main link. Argument: s (string)
“¡ẎṢɱ» Yield "aeuoi"; concatenate "a" with the dictionary word "euoi".
f€ Filter each character in s by presence in "aeuoi".
This yields A, an array of singleton and empty strings.
ð Begin a new, dyadic chain. Left argument: A. Right argument: s
œp Partition s at truthy values (singleton strings of vowels) in A.
FẊ¥ Flatten and shuffle A. This yields a permutation of the vowels.
ż Zip the partition of consonants with the shuffled vowels.
```
[Answer]
# R, ~~99~~ ~~98~~ 89 bytes
```
x=el(strsplit(readline(),""))
z=grepl("[aeiou]",x)
x[z]=x[sample(which(z))]
cat(x,sep="")
```
Seems to be the first human-readable solution! Thanks to [Giuseppe](https://codegolf.stackexchange.com/users/67312/giuseppe) for saving 9 bytes!
Test cases:
```
tho qaeck bruwn fux jemps over tho lozy dig.
progremmang pozzlos & cide gulf
```
Seems that there is no way to make an internal variable assignment (inside, like, `cat`), and again some people are going to prove I am wrong...
[Answer]
## CJam, 23 bytes
```
lee_{"aeiou"&},_mrerWf=
```
[Try it online!](http://cjam.tryitonline.net/#code=bGVlX3siYWVpb3UiJn0sX21yZXJXZj0&input=c2hlbmFuaWdhbnM)
### Explanation
```
l e# Read input, e.g. "foobar".
ee e# Enumerate, e.g. [[0 'f] [1 'o] [2 'o] [3 'b] [4 'a] [5 'r]].
_ e# Duplicate.
{"aeiou"&}, e# Keep those which have a non-empty intersection with this string
e# of vowels, i.e. those where the enumerated character is a vowel.
e# E.g. [[1 'o] [2 'o] [4 'a]].
_ e# Duplicate.
mr e# Shuffle the copy. E.g. [[2 'o] [4 'a] [1 'o]].
er e# Transliteration. Replaces elements from the sorted copy with
e# the corresponding element in the shuffled copy in the original list.
e# [[0 'f] [2 'o] [4 'a] [3 'b] [1 'o] [5 'r]].
Wf= e# Get the last element of each pair, e.g. "foabor".
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 17 bytes
```
žMÃ.r`¹vžMyå_iy}?
```
**Explanation**
```
žMÃ # get all vowels from input
.r` # randomize them and place on stack
¹v # for each in input
žMyå_i } # if it is not a vowel
y # push it on stack
? # print top of stack
```
[Try it online!](http://05ab1e.tryitonline.net/#code=xb5Nw4MucmDCuXbFvk15w6VfaXl9Pw&input=dGhlIHF1aWNrIGJyb3duIGZveCBqdW1wcyBvdmVyIHRoZSBsYXp5IGRvZy4)
[Answer]
# Python 3, 109 bytes
Only supports lowercase vowels.
Thanks to @Alissa for saving an extra byte.
```
import re,random
def f(s):r='[aeiou]';a=re.findall(r,s);random.shuffle(a);return re.sub(r,lambda m:a.pop(),s)
```
[**Ideone it!**](http://ideone.com/78JIDe)
[Answer]
# TSQL, 275 bytes
**Golfed:**
```
DECLARE @ VARCHAR(99)='the quick brown fox jumps over the lazy dog.'
;WITH c as(SELECT LEFT(@,0)x,0i UNION ALL SELECT LEFT(substring(@,i+1,1),1),i+1FROM c
WHERE i<LEN(@)),d as(SELECT *,rank()over(order by newid())a,row_number()over(order by 1/0)b
FROM c WHERE x IN('a','e','i','o','u'))SELECT @=STUFF(@,d.i,1,e.x)FROM d,d e
WHERE d.a=e.b PRINT @
```
**Ungolfed:**
```
DECLARE @ VARCHAR(max)='the quick brown fox jumps over the lazy dog.'
;WITH c as
(
SELECT LEFT(@,0)x,0i
UNION ALL
SELECT LEFT(substring(@,i+1,1),1),i+1
FROM c
WHERE i<LEN(@)
),d as
(
SELECT
*,
rank()over(order by newid())a,
row_number()over(order by 1/0)b
FROM c
WHERE x IN('a','e','i','o','u')
)
SELECT @=STUFF(@,d.i,1,e.x)FROM d,d e
WHERE d.a=e.b
-- next row will be necessary in order to handle texts longer than 99 bytes
-- not included in the golfed version, also using varchar(max) instead of varchar(99)
OPTION(MAXRECURSION 0)
PRINT @
```
**[Fiddle](https://data.stackexchange.com/stackoverflow/query/531859/sheffle-tho-vawols-ureund)**
[Answer]
# Perl, 38 bytes
Includes +1 for `-p`
Run with the sentence on STDIN
```
vawols.pl <<< "programming puzzles & code golf"
```
`vawols.pl`:
```
#!/usr/bin/perl -p
@Q=/[aeiou]/g;s//splice@Q,rand@Q,1/eg
```
[Answer]
# Java 7, ~~243~~ 241 bytes
```
import java.util.*;String c(char[]z){List l=new ArrayList();char i,c;for(i=0;i<z.length;i++)if("aeiou".indexOf(c=z[i])>=0){l.add(c);z[i]=0;}Collections.shuffle(l);String r="";for(i=0;i<z.length;i++)r+=z[i]<1?(char)l.remove(0):z[i];return r;}
```
Yes, this can probably be golfed quite a bit, but Java doesn't have any handy built-ins for this a.f.a.i.k... Also, I kinda forgot the codegolfed array-variant for `Collections.shuffle`..
**Ungolfed & test cases:**
[Try it here.](https://ideone.com/DrIglP)
```
import java.util.*;
class M{
static String c(char[] z){
List l = new ArrayList();
char i,
c;
for(i = 0; i < z.length; i++){
if("aeiou".indexOf(c = z[i]) >= 0){
l.add(c);
z[i] = 0;
}
}
Collections.shuffle(l);
String r = "";
for(i = 0; i < z.length; i++){
r += z[i] < 1
? (char)l.remove(0)
: z[i];
}
return r;
}
public static void main(String[] a){
System.out.println(c("".toCharArray()));
System.out.println(c("a".toCharArray()));
System.out.println(c("cwm".toCharArray()));
System.out.println(c("the quick brown fox jumps over the lazy dog.".toCharArray()));
System.out.println(c("abcdefghijklmnopqrstuvwxyz".toCharArray()));
System.out.println(c("programming puzzles & code golf".toCharArray()));
System.out.println(c("fatalize".toCharArray()));
System.out.println(c("martin ender".toCharArray()));
}
}
```
**Possible output:**
```
a
cwm
tha queck brown fox jumps evor tho lezy dig.
ebcdifghujklmnopqrstavwxyz
prigrommeng puzzlos & cade golf
fatelazi
mertan inder
```
[Answer]
# [Perl 6](http://perl6.org/), 65 bytes
```
{my \v=m:g/<[aeiou]>/;my @a=.comb;@a[v».from]=v.pick(*);@a.join}
```
Anonymous function. Assumes lower-case input.
([try it online](https://glot.io/snippets/ei0d9dkfpl))
[Answer]
# Ruby 45 + 1 = 46 bytes
+1 byte for `-p` flag
```
a=$_.scan(e=/[aeiou]/).shuffle
gsub(e){a.pop}
```
[Answer]
# Bash, 75 bytes
```
paste -d '' <(tr aeoiu \\n<<<$1) <(grep -o \[aeiou]<<<$1|shuf)|paste -sd ''
```
Takes the string as an argument and prints the result to stdout.
Eg
```
for x in "" "a" "cwm" \
"the quick brown fox jumps over the lazy dog." \
"abcdefghijklmnopqrstuvwxyz" \
"programming puzzles & code golf" \
"fatalize" "martin ender"; do
echo "$x";. sheffle.sh "$x"; echo
done
```
prints
```
<blank line>
<blank line>
a
a
cwm
cwm
the quick brown fox jumps over the lazy dog.
tho quuck brown fix jamps ever the lozy dog.
abcdefghijklmnopqrstuvwxyz
ibcdefghajklmnopqrstuvwxyz
programming puzzles & code golf
progremmong pazzlus & cedo gilf
fatalize
fetilaza
martin ender
mertan endir
```
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 39 bytes
```
@eI:1aToS,I:2f@~:LcS,Tc
.'~e@V;
e.~e@V,
```
[Try it online!](http://brachylog.tryitonline.net/#code=QGVJOjFhVG9TLEk6MmZAfjpMY1MsVGMKLid-ZUBWOwplLn5lQFYs&input=InRoZSBxdWljayBicm93biBmb3gganVtcHMgb3ZlciB0aGUgbGF6eSBkb2cuIg&args=Wg)
### Explanation
* Main predicate:
```
@eI I is the list of chars of the input.
:1aT T is I where all vowels are replaced with free variables.
oS, S is T sorted (all free variables come first).
I:2f Find all vowels in I.
@~ Shuffle them.
:LcS, This shuffle concatenated with L (whatever it may be) results in S.
This will unify the free variables in S with the shuffled vowels.
Tc Output is the concatenation of elements of T.
```
* Predicate 1:
```
. Input = Output…
'~e@V …provided that it is not a vowel.
; Otherwise Output is a free variable.
```
* Predicate 2:
```
e. Output is an element of the input…
~e@V, … and it is a vowel.
```
[Answer]
## Javascript (ES6), ~~78~~ 76 bytes
```
s=>s.replace(r=/[aeiou]/g,_=>l.pop(),l=s.match(r).sort(_=>Math.random()-.5))
```
*Saved 2 bytes thanks to apsillers*
### Alternate version proposed by apsillers (76 bytes as well)
```
s=>s.replace(r=/[aeiou]/g,[].pop.bind(s.match(r).sort(_=>Math.random()-.5)))
```
### Test
```
let f =
s=>s.replace(r=/[aeiou]/g,_=>l.pop(),l=s.match(r).sort(_=>Math.random()-.5))
console.log(f("the quick brown fox jumps over the lazy dog."))
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), 15 bytes
```
tt11Y2m)tnZr7M(
```
[Try it online!](http://matl.tryitonline.net/#code=dHQxMVkybSl0blpyN00o&input=J3RoZSBxdWljayBicm93biBmb3gganVtcHMgb3ZlciB0aGUgbGF6eSBkb2cuJw)
### Explanation
```
tt % Take input string implicitly. Duplicate twice
11Y2 % Predefined string: 'aeiou'
m % Logical index that contains true for chars of the input that are vowels
) % Get those chars from the input string. Gives a substring formed by the
% vowels in their input order
tnZr % Random permutation of that substring. This is done via random sampling
% of that many elements without replacement
7M % Push logical index of vowel positions again
( % Assign the shuffled vowels into the input string. Display implicitly
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) v2.0a0, ~~14~~ 13 bytes
```
ō²f\v
NÌr\v@o
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=9rJmXHYKTsxyXHZAbw==&input=InRoaXMgaXMgYSB0ZXN0IgotUQ==)
---
## Explanation
```
:Implicit input of string U.
ö² :Generate a random permutation of U.
f\v :Get all the vowels as an array.
\n :Assign that array to U.
NÌ :Get the last element in the array of inputs (i.e., the original value of U)
r\v :Replace each vowel.
@o :Pop the last element from the array assigned to U above.
```
[Answer]
# Pyth, 26 bytes
```
J"[aeiou]"s.i:QJ3.Sf}TPtJQ
```
A program that takes input of a quoted string and prints the shuffled string.
[Try it online](https://pyth.herokuapp.com/?code=J%22%5Baeiou%5D%22s.i%3AQJ3.Sf%7DTPtJQ&test_suite=1&test_suite_input=%22%22%0A%22a%22%0A%22cwm%22%0A%22the+quick+brown+fox+jumps+over+the+lazy+dog.%22%0A%22abcdefghijklmnopqrstuvwxyz%22%0A%22programming+puzzles+%26+code+golf%22%0A%22fatalize%22%0A%22martin+ender%22&debug=0)
**How it works**
```
J"[aeiou]"s.i:QJ3.Sf}TPtJQ Program. Input: Q
J"[aeiou]" J="[aeiou]"
:QJ3 Split Q on matches of regex J, removing vowels
PtJ J[1:-1], yielding "aeiou"
f}T Q Filter Q on presence in above, yielding vowels
.S Randomly shuffle vowels
.i Interleave non-vowel and vowel parts
s Concatenate and implicitly print
```
[Answer]
# PHP, ~~144~~ 129 bytes
Using lowercase input
```
$r=Aaeiou;$v=str_shuffle(preg_replace("#[^$r]+#",'',$a=$argv[1]));for(;$i<strlen($a);)echo strpos($r,$a[$i++])?$v[$j++]:$a[$i-1];
```
Explanation:
```
$r="aeiou"; // set vowels
preg_replace("#[^$r]+#",'',$argv[1]) // find all vowels in input
$v=str_shuffle() // shuffle them
for(;$i<strlen($a);) // run through the text
strpos($r,$a[$i++])?$v[$j++]:$a[$i-1]; // if it's a vowel print the j-th shuffled vowel else print original text
```
[Answer]
## Actually, 24 bytes
```
;"aeiou";╗@s@`╜íu`░╚@♀+Σ
```
[Try it online!](http://actually.tryitonline.net/#code=OyJhZWlvdSI74pWXQHNAYOKVnMOtdWDilpHilZpA4pmAK86j&input=Im1lZ28i)
Explanation:
```
;"aeiou";╗@s@`╜íu`░╚@♀+Σ
; dupe input
"aeiou";╗ push vowels, store a copy in reg0
@s split one copy of input on vowels
@`╜íu`░ take characters from other copy of input where
╜íu the character is a vowel (1-based index of character in vowel string is non-zero)
╚ shuffle the vowels
@♀+ interleave and concatenate pairs of strings
Σ concatenate the strings
```
[Answer]
# Bash, 89
Assumes all input to be lowercase.
```
a=`tee z|grep -o [aeiou]`
[ -n "$a" ]&&tr `tr -d \ <<<$a` `shuf -e $a|tr -d '
'`<z||cat z
```
[Answer]
## PowerShell v3+, ~~155~~ 99 bytes
```
param([char[]]$n)$a=$n|?{$_-match'[aeiou]'}|sort{random};-join($n|%{if($_-in$a){$a[$i++]}else{$_}})
```
*Big props to @[Ben Owen](https://codegolf.stackexchange.com/users/56849/ben-owen) for the 56-byte golf*
Takes input `$n`, expecting all lowercase, immediately casts it as a `char`-array.
We pipe that into a `Where-Object` clause to pull out those elements that `-match` a vowel, pipe them to `Sort-Object` with `{Get-Random}` as the sorting mechanism. Calling `Get-Random` without qualifiers will return an integer between `0` and `[int32]::MaxValue` -- i.e., assigning random weights to each element on the fly. We store the randomized vowels into `$a`.
Finally, we loop through `$n`. For each element, `|%{...}`, if the current character is somewhere `-in` `$a`, we output the next element in `$a`, post-incrementing `$i` for the next time. Otherwise, we output the current character. That's all encapsulated in parens and `-join`ed together into a string. That string is left on the pipeline, and output is implicit at program conclusion.
### Test cases
```
PS C:\Tools\Scripts\golfing> 'a','cwm','the quick brown fox jumps over the lazy dog.','abcdefghijklmnopqrstuvwxyz','programming puzzles & code golf','fatalize','martin ender'|%{.\vawols.ps1 $_}
a
cwm
thu qaeck brown fix jomps ovor thu lezy deg.
abcdofghejklmnupqrstivwxyz
prugrammong pizzles & code golf
fitaleza
mertin endar
```
[Answer]
# Python 3, 106 bytes
Lowercase only.
```
import re,random
def f(s):s=re.split('([aeiou])',s);v=s[1::2];random.shuffle(v);s[1::2]=v;return''.join(s)
```
[Answer]
# [PHP >= 5.3](http://sandbox.onlinephpfunctions.com/), ~~139~~ 136 bytes (and no errors thrown)
```
array_map(function($a,$b){echo$a.$b;},preg_split("/[aeiou]/",$s=$argv[1]),str_split(str_shuffle(implode(preg_split("/[^aeiou]/",$s)))));
```
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 29 bytes
**Solution:**
```
{x[a:&x in"aeiou"]:x@(-#a)?a}
```
[Try it online!](https://tio.run/##y9bNz/7/v7oiOtFKrUIhM08pMTUzv1Qp1qrCQUNXOVHTPrFWqSQjVaGwNDM5WyGpKL88TyEtv0IhqzS3oFghvyy1SAEknZNYVamQkp@up/T/PwA "K (oK) – Try It Online")
**Examples:**
```
"pregrommeng pizzlas & codo gulf"
{x[a:&x in"aeiou"]:x@(-#a)?a}"programming puzzles & code golf"
"pregremmong puzzlos & coda gilf"
{x[a:&x in"aeiou"]:x@(-#a)?a}"programming puzzles & code golf"
"pregrommeng pazzlos & cidu golf"
```
**Explanation:**
Find locations of the vowels and replace with the vowels drawn in a random order.
```
{x[a:&x in"aeiou"]:x@(-#a)?a} / the solution
{ } / anonymous function with input x
x[ ] / index into x at these indices
x in"aeiou" / is character a vowel
& / indices where true
a: / assign to add
: / assign
?a / draw randomly from a
( ) / do this together
#a / count length of a
- / negate (draws from list, no duplication)
x@ / apply these indices to input
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 21 [bytes](https://github.com/abrudz/SBCS)
```
{⍵[?⍨≢⍵]}@{⍵∊'AEIOU'}
```
[Try it online!](https://tio.run/##hY/NToNAFIX3PMVdOSWpPoAbpTCltMBQCv3BuKDtUEn4szMsGtOt0SZNjHs3XfkCvhAvUgFLY9y4mu@ec@bkXj@LLpcbP0pXx2L/AWbK6TW4WUbXC59RCJMs5xAy8BnLY7o8PhX7r7ubYv9ZvB5KvN/eVkrxskMS1oiLtse6x/DDBII8WfAwTaDF8nkcMlayKAgBFM9v8G@RIFRFDmX8XCQIvBqr78Xu0EYlvQNqB7@i9dZBuo59/qNq9QVVkOS8xD9ZBq2kvpmyhZ9RYGGyiig85qVYekiE@QaWaT6PSgP4A41LEYniaRWETq/UgDwxGnR6GIauJg@gY5OJCV0yhb5rWCMgY2xDZeuSNwOFqFfnno6s4K7a0/oD3TCJNbRHjjueTGdek7BsotqSYWimCpbreToewQXIRMGgEr3bxLqSI@mah5vZkGxHMwGbCrbRNw "APL (Dyalog Unicode) – Try It Online")
Assumes uppercase.
[Answer]
# [Kotlin](https://kotlinlang.org), ~~122~~ 118 bytes
```
x->val v=x.filter{"aeiuo".contains(it)}.toList().shuffled()
x.split(Regex("[aeiou]")).reduceIndexed{i,a,s->a+v[i-1]+s}
```
[Try it online!](https://tio.run/##bVBNa8MwDL3nV4gchkMbw66F9j7YaTuWHtxYdt36I/VH6ibkt2cu22lEIJDe0@NJurmolV1EsmCYsmRgnnkJJcMOvqNXVjYwVVCiL03UlghS103zH2IrWPcwK2i8INyT6m5w9u5hQbgM12T6AG5ADy9as/EJ3Em6ZnTuOAp5UdebNtb1dx9iGh75Oa4M995Jz4wpZ0CfxlFjgDfoHEeQTosVhWCRaTXiCmWYj8oCWo7@RVdzVQ1Mg9iRv0@1h99iPy25Pby4YZ@pUDqin2qGKrmads7G8upAVGxmGt2nCpE0NFySEBo5aapMQ69VJF8oMZP6WIQunYol9chThx9lg4x8Ulu2De2BbYajat9PmzAv8/ID "Kotlin – 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/162302/edit).
Closed 5 years ago.
[Improve this question](/posts/162302/edit)
Input is in this format:
```
image fontwidth fontheight rowwidth xoffset yoffset xgap ygap non-existent charstart thetextitself
```
thetextitself: The text that should be rendered from the image.
image: The image filename. Implementation may vary; it could be either the filename from your computer, an image URL, or something else, as long as it's possible to use any picture.
fontwidth, fontheight: self explanatory
rowwidth: How many characters a row of characters contains in the image?
xoffset: The starting x coordinate of the character table.
yoffset: The starting y coordinate of the character table.
xgap: The horizontal gap between characters.
ygap: The vertical gap between characters.
non-existent: The character code for the character rendered if the character is (fully or partially) outside the image, hexadecimal of any length.
charstart: The hexadecimal first character any length.
thetextitself: The text to render. The previous parameters are used to find the characters. It's at the end, so that any space included doesn't clash with the next parameter.
So, the appropriate input for this image  would be:
```
https://i.stack.imgur.com/E8FBP.png 7 11 8 3 5 2 1 00000000 00000 <Test>
```
which would render as . The exact pixel colors are preserved.
Word wrapping is not needed, but if you use word wrapping, there must be at least 16 characters of horizontal space.
-10 bytes if the code renders tabs (U+0009) correctly (jumps to the next position divisible by 8).
-10 bytes if the code renders Microsoft Windows newlines (U+000D000A) correctly (extends the output image height and jumps to the beginning of the last line).
-10 bytes if the code interprets the combining and zero–width characters as zero–width, but combining characters overlapping their glyph to the next (or the previous; I don't know how Unicode combining characters work) character.
The code must support Unicode characters up to U+FFFF. If the code allows for characters above, -10 bytes.
It's , so the lowest code size wins.
]
|
[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 5 years ago.
[Improve this question](/posts/161861/edit)
Not sure if this is the correct community to post this is. But as I see this problem as an interesting puzzle to solve, I'd thought to give it a shot...
# Problem Statement:
Let`s say we have:
* N collections of parts: A, B,C,D,...etc
* Each collection consists of n parts: 1,2,3,4,5 ...
* All these parts are randomly present in an input buffer:
B1, C5, D2,A4,A2, etc
The aim now is to sort all parts into their collections, and make sure that in each collection the parts are ordered correctly.
A desired output would be: A1,A2,A3,A4,A5 B1,B2,B3,B4,B5, ..etc
This will be a physical process in which the parts are sheets of material. This gives some real world constraints:
1. A sorting and output buffer of Nb locations is available.
2. On each of the buffer locations multiple sheets can be stacked.
3. To retrieve one particular sheet, all sheets that are placed on top of it need to be moved (and temporarily stored in another location). This takes physical effort + time and should therefor be minimized.
4. It is not possible to move a correctly ordered subset of a collection at once. This would involve picking up each sheet individually from it's stack.
5. Once a collection is completely sorted and ordered, it can be removed from the buffer.
The question:
I am getting to grips with the logic of this sorting and ordering problem. Some initial questions I have asked myself, and you might find interesting to think about/test/simulate.
* For a given input (N, n) what is an efficient number of buffer locations (Nb)?
* What should be the sorting logic in this problem? Which rules would work when N scales to max. 30 and n to max. 150
* Does anyone have sources (papers, articles, algorithms, etc) on this type of problem?
* What aspect of the system should be changed to make the sorting more efficient? For instance what would be the benefit of being able to physically move a subset of a collection at once, while maintaining it's ordering.
I was struggling with clearly writing down the specifics of this sorting and ordering problem, if something is unclear, let me know so I can provide more info.
Thanks!!
]
|
[Question]
[
# Definition
The infinite spiral used in this question has `0` on the position `(0,0)`, and continues like this:
```
16-15-14-13-12
| |
17 4--3--2 11
| | | |
18 5 0--1 10
| | |
19 6--7--8--9
|
20--21...
```
It is to be interpreted as a Cartesian plane.
For example, `1` is on the position `(1,0)`, and `2` is on the position `(1,1)`.
# Task
Given a non-negative integer, output its position in the spiral.
# Specs
* Your spiral can start with `1` instead of `0`. If it starts with `1`, please indicate so in your answer.
* Output the two numbers in any sensible format.
# Testcases
The testcases are 0-indexed but you can use 1-indexed as well.
```
input output
0 (0,0)
1 (1,0)
2 (1,1)
3 (0,1)
4 (-1,1)
5 (-1,0)
6 (-1,-1)
7 (0,-1)
8 (1,-1)
9 (2,-1)
100 (-5,5)
```
[Answer]
## Python, 46 bytes
```
f=lambda n:n and 1j**int((4*n-3)**.5-1)+f(n-1)
```
[Dennis's answer](https://codegolf.stackexchange.com/a/87185/20260) suggested the idea of summing a list of complex numbers representing the unit steps. The question is how to find the number of quarter turns taken by step `i`.
```
[0, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7]
```
These are generated by `int((4*k-n)**.5-1)`, and then converted to a direction unit vector via the complex exponent `1j**_`.
[Answer]
# Python, 53 bytes
```
lambda n:sum(1j**int((4*i+1)**.5-1)for i in range(n))
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~22~~ ~~16~~ 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ḷ×4‘ƽ’ı*S
```
This uses the quarter-turn approach from [@xnor's](https://codegolf.stackexchange.com/a/87188)/[@orlp's](https://codegolf.stackexchange.com/a/87187) answer.
Indexing is 0-based, output is a complex number. [Try it online!](http://jelly.tryitonline.net/#code=4bi2w5c04oCYw4bCveKAmcSxKlM&input=&args=MTAw) or [verify all test cases](http://jelly.tryitonline.net/#code=4bi2w5c04oCYw4bCveKAmcSxKlMKMTDhuLY7MTAwwrU7IsOH4oKsRw&input=).
### How it works
```
Ḷ×4‘ƽ’ı*S Main link. Argument: n (integer)
Ḷ Unlength; create the range [0, ..., n - 1].
×4 Multiply all integers in the range by 4.
‘ Increment the results.
ƽ Take the integer square root of each resulting integer.
’ Decrement the roots.
ı* Elevate the imaginary unit to the resulting powers.
S Add the results.
```
[Answer]
# Python 2, ~~72~~ 62 bytes
```
n=2;x=[]
exec'x+=n/2*[1j**n];n+=1;'*input()
print-sum(x[:n-2])
```
*Thanks to @xnor for suggesting and implementing the quarter-turn idea, which saved 10 bytes.*
Indexing is 0-based, output is a complex number. Test it on [Ideone](http://ideone.com/EHfyPJ).
[Answer]
# Ruby, ~~57~~ 55 bytes
This is a simple implementation based on [Dennis's Python answer](https://codegolf.stackexchange.com/a/87185/47581). Thanks to Doorknob for his help in debugging this answer. Golfing suggestions welcome.
```
->t{(1...t).flat_map{|n|[1i**n]*(n/2)}[0,t].reduce(:+)}
```
**Ungolfed:**
```
def spiral(t)
x = []
(1...t).each do |n|
x+=[1i**n]*(n/2)
end
return x[0,t].reduce(:t)
end
```
[Answer]
## JavaScript (ES7), 75 bytes
```
n=>[0,0].map(_=>((a+2>>2)-a%2*n)*(a--&2?1:-1),a=(n*4+1)**.5|0,n-=a*a>>2)
```
Who needs complex arithmetic? Note: returns `-0` instead of `0` in some cases.
[Answer]
## Batch, 135 bytes
```
@set/an=%1,x=y=f=l=d=0,e=-1
:l
@set/ac=-e,e=d,d=c,n-=l+=f^^=1,x+=d*l,y+=e*l
@if %n% gtr 0 goto l
@set/ax+=d*n,y+=e*n
@echo %x%,%y%
```
Explanation: Follows the spiral out from the centre. Each pass through the loop rotates the current direction `d,e` by 90° anticlockwise, then the length of the arm `l` is incremented on alternate passes via the flag `f` and the next corner is calculated in `x,y`, until we overshoot the total length `n`, at which point we backtrack and print the resulting co-ordinates.
] |
[Question]
[
This should be a simple challenge.
Given a number \$n \ge 0\$, output the [super-logarithm](https://en.wikipedia.org/wiki/Super-logarithm) (or the \$\log^\*\$, log-star, or [iterated logarithm](https://en.wikipedia.org/wiki/Iterated_logarithm), which are equivalent since \$n\$ is never negative for this challenge.) of \$n\$.
$$\log^\*(n) = \begin{cases}
0 & \text{ if } n \le 1 \\
1 + \log^\*(\log(n)) & \text{ if } n > 1
\end{cases}$$
This is one of the two inverse functions to [tetration](https://en.wikipedia.org/wiki/Tetration). The other is the [super-root](https://en.wikipedia.org/wiki/Super-root), which is in a [related question](https://codegolf.stackexchange.com/questions/20308/calculate-the-super-root-of-a-number).
### Examples
```
Input Output
0 0
1 0
2 1
3 2
4 2
...
15 2
16 3
...
3814279 3
3814280 4
```
### Rules
* You do not need to support decimals, though you may.
* You need to support input of at least \$3814280 = \left\lceil e^{e^e} \right\rceil\$.
* **You may not hard-code the values like `3814280`. (Your program must *theoretically* support higher numbers.) I want an algorithm to be implemented.**
* Shortest code wins.
[**Related OEIS**](https://oeis.org/search?q=3814280&sort=&language=english&go=Search)
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ÆlÐĿĊḊi1
```
[Try it online!](http://jelly.tryitonline.net/#code=w4Zsw5DEv8SK4biKaTE&input=&args=MzgxNDI4MA) or [verify all test cases](http://jelly.tryitonline.net/#code=w4Zsw5DEv8SK4biKaTEKxbzDh-KCrEc&input=&args=MCwgMSwgMiwgMywgNCwgMTUsIDE2LCAzODE0Mjc5LCAzODE0Mjgw).
### Background
We start by successively taking natural logarithms of the input and the subsequent results until the result no longer changes. This works because the extension of the natural logarithm to the complex plane has a [fixed point](https://en.wikipedia.org/wiki/Fixed_point_(mathematics)); if **z = e-W(-1) ≈ 0.318 + 1.337i** – where **W** denotes the [Lambert W function](https://en.wikipedia.org/wiki/Lambert_W_function) – we have **log(z) = z**.
For input **n**, after computing **[n, log(n), log(log(n)), …, z]**, we first apply the ceiling function to each of the results. Jelly's implementation (`Ċ`) actually computes the imaginary part of *complex* number instead†, but we're not interested in these anyway.
Once the **k**th application of **log** yields a value less than or equal to **1**, `Ċ` will return **1** for the first time. The 0-based index of that first **1** is the desired result.
The straightforward implementation (compute 1-based index, decrement) fails because of edge case **0**, which does not have a **1** in its list of logarithms. In fact, for input **0**, the sequence of logarithms is
```
[0, None]
```
This is because Jelly's logarithm (`Æl`) is overloaded; it first tries `math.log` (real logarithm), then `cmath.log` (complex logarithm), and finally "gives up" and returns `None`. Fortunately, `Ċ` is similarly overloaded and simply returns it argument if it cannot round up or take an imaginary part.
Likewise, input **1** returns
```
[1, 0, None]
```
which may create problems in other approaches that do or do not involve `Ċ`.
One way to fix this problem is apply `Ḋ` (dequeue; removes first element) to the array of logarithms. This maps
```
0ÆlÐĿ -> [0, None] -> [None]
1ÆlÐĿ -> [1, 0, None] -> [0, None]
```
so neither list has a **1** now. This way, finding the index of the first **1** will return **0** (not found), which is the desired output for inputs **0** and **1**.
### How it works
```
ÆlÐĿĊḊi1 Main link. Argument: n (non-negative integer)
ÐĿ Apply the following link until the results are no longer unique.
Æl Natural logarithm.
Return the array of all unique results.
Ċ Round all resulting real numbers up to the nearest integer. This takes
the imaginary part of complex numbers and does nothing for non-numbers.
Ḋ Dequeue; remove the first item (n) of the array of results.
i1 Find the first index of 1 (0 if not found).
```
---
† This is one of the only three atoms in Jelly that are overloaded in a non-obvious manner.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
Æl>1$пL’
```
[Try it online!](http://jelly.tryitonline.net/#code=w4ZsPjEkw5DCv0zigJk&input=&args=MzgxNDI4MA)
[Test suite.](http://jelly.tryitonline.net/#code=w4ZsPjEkw5DCv0zigJkKw4figqw&input=&args=WzAsMSwyLDMsNCwxNSwxNiwzODE0Mjc5LDM4MTQyODBd) (Slightly modified.)
### Explanation
```
Æl>1$пL’
п while loop, collect all intermediate results.
>1$ condition: z>1
Æl body: natural logarithm.
L length of the array containing all intermediate results,
meaning number of iterations
’ minus one.
```
[Answer]
# Javascript, ~~45~~ ~~27~~ 26 bytes
```
l=a=>a>1&&1+l(Math.log(a))
```
[Here is test suite](https://repl.it/CdiG/3) (3rd rev)
Thanks @LeakyNun for saving 1 byte with conditional and then converting function to lambda, and @Neil for pointing out false is ok return value for <=1 (changed test to be == instead of ===)
[Answer]
# C, 38 bytes
```
f(double n){return n>1?1+f(log(n)):0;}
```
Pretty self-explanatory.
[Try it on ideone.](http://ideone.com/pGW2HR)
[Answer]
# Mathematica, 21 bytes
```
If[#>1,1+#0@Log@#,0]&
```
Recursive anonymous function. Takes an integer as input and returns its super-logarithm as output. Just uses the given definition.
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 13 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
Direct translation of OP:
```
{⍵≤1:0⋄1+∇⍟⍵}
```
[TryAPL](http://tryapl.org/?a=%7B%u2375%u22641%3A0%u22C41+%u2207%u235F%u2375%7D%A80%201%202%203%204%2015%2016%203814279%203814280&run) online!
[Answer]
# Pyth, 10 bytes
```
L&>b1hy.lb
```
[Test suite.](http://pyth.herokuapp.com/?code=L%26%3Eb1hy.lb%29y&test_suite=1&test_suite_input=0%0A1%0A2%0A3%0A4%0A15%0A16%0A3814279%0A3814280&debug=0)
This defines a function.
[Answer]
## Haskell, 23 bytes
```
l x|x>1=1+l(log x)|1<2=0
```
Usage example: `l 3814280` -> `4`.
[Answer]
# Python 3, 45 bytes
```
import math
s=lambda x:x>1and-~s(math.log(x))
```
For `x <= 1`, this returns `False` (which is `== 0` in Python).
[Answer]
## 05AB1E, ~~16~~ 13 bytes
```
[Dî2‹#¼žr.n]¾
```
**Explanation**
```
# implicit input n
[ ] # infinite loop
Dî2‹# # break if n rounded up is less than 2
¼ # else, increase counter
žr.n # set next n = log(n)
¾ # push counter and implicitly print
```
[Try it online](http://05ab1e.tryitonline.net/#code=W0TDrjLigLkjwrzFvnIubl3Cvg&input=MzgxNDI4MA)
[Answer]
# [J](http://jsoftware.com/), ~~21~~ ~~19~~ ~~18~~ 16 bytes
*Saved 2 bytes to Leaky Nun, 1 byte to Galen Ivanov, and 2 bytes to FrownyFrog!*
```
2#@}.(0>.^.)^:a:
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/jZQdavU0DOz04vQ046wSrf5rcilwpSZn5CukKRjAGIZwISMYwxjGMIErMoWzzOCqLAxNjCwM/gMA "J – Try It Online")
## Test cases
```
ls =: >:@$:@^.`0:@.(<:&1)
ls 0
0
ls 1
0
ls 2
1
ls 3
2
ls 4
2
ls 15
2
ls 16
3
ls 3814280
4
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~15~~ 12 bytes
```
0`ZetG>~}x@q
```
[Try it online!](http://matl.tryitonline.net/#code=MGBaZXRHPn59eEBx&input=MzgxNDI3OQ) Or [verify all test cases](http://matl.tryitonline.net/#code=YFhLeAowYFpldEs-fn14QHEKXURU&input=MAoxCjIKMwo0CjE1CjE2CjM4MTQyNzkKMzgxNDI4MA) (slightly modified version to handle several inputs).
### How it works
Starting with 0, apply iterated exponentiation until exceeding the input. The output is the number of iterations minus 1.
```
0 % Push 0
` % Do...while loop
Ze % Exponential
t % Duplicate
G % Push input
>~ % Is current value less than or equal to the input? If so: next iteration
} % Finally (code executed at the end of the last iteration)
x % Delete
@q % Iteration index minus 1
% Implicitly end loop
% Implicitly display stack
```
[Answer]
# Julia, 17 bytes
```
!x=x>1&&1+!log(x)
```
[Try it online!](http://julia.tryitonline.net/#code=IXg9eD4xJiYxKyFsb2coeCkKCmZvciBuIGluIFswOjQ7IFsxNSwgMTYsIDM4MTQyNzksIDM4MTQyODBdXQogICAgQHByaW50ZigiJTdkIC0-ICVkXG4iLCBuLCAhbikKZW5k&input=)
[Answer]
# Java 7, 47 bytes
```
int c(double n){return n>1?1+c(Math.log(n)):0;}
```
[Try it online.](https://tio.run/##ZY/NCoJAEMfvPcXgaRdJ1KxMoZ7Ak8fosKnYmq7ijkKIz26rCSodf8P8vzLWsn0Wv4coZ1JCwLjodgASGfIIBi4QIhKXzTNPQNCuTrCpBYirdbP0iAQMX0ZepkRQ6pl@PyhppX6VdHZoSx5DoVxJiDUX6f0BjI4JAJhIJCb1F7DWYK/hsAZnozlu6LRRuZZjny9/J/eX2u@WpVPP6WOczOeK4UdiUhhlg0al2mMuCNc1DzS1ndPZpB@@)
The recursive Java 7 style method above is 2 bytes shorter than an iterative Java 8 style lambda:
```
n->{int c=0;for(;n>1;c++)n=Math.log(n);return c;}
```
[Try it online.](https://tio.run/##ZY/NjsIwDITvPIXFKVVF1fK3QFTeAC4cEYdsGthAcVDiIiHUZy9ptodWXCx9I894fBVPMbkWt0aWwjnYCY3vEYBGUvYspIJ9i0EAyQpT/ZYKMOJerEd@OBKkJewBIYcGJ9t32MxTfjaWcdxmXMZxhPlO0F9SmgvzZquosgiS1w1vQx4@1Yd0WU@jC7j7IuxAVuPleAIR/bcg5Yil4XoHWR@mfZj1YT7wLAa0HLhW2Xz6s/6SVunXz6Fn2Ghf1l3Fw8uRuiemouTh21OJTMfjDYxjTCTTURdTNx8)
**Explanation:**
```
int c(double n){ // Method with double parameter and integer return-type
return n>1? // If the input is larger than 1:
1+ // Return 1 +
c(Math.log(n)) // A recursive call with log(input)
: // Else:
0; // Return 0 instead
n->{ // Method with double parameter and integer return-type
int c=0; // Create a counter, starting at 0
for(;n>1; // Loop as long as the input is still larger than 1:
c++) // Increase the counter by 1
n=Math.log(n); // And update the input to log(input)
return c;} // After the loop: return the counter as result
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
-Ælß$Ị?‘
```
Straightforward implementation of the definition. [Try it online!](http://jelly.tryitonline.net/#code=LcOGbMOfJOG7ij_igJg&input=&args=MzgxNDI4MA) or [verify all test cases](http://jelly.tryitonline.net/#code=LcOGbMOfJOG7ij_igJgKxbzDh-KCrEc&input=&args=MCwgMSwgMiwgMywgNCwgMTUsIDE2LCAzODE0Mjc5LCAzODE0Mjgw).
### How it works
```
-Ælß$Ị?‘ Main link. Argument: x
Ị Insignificant; test if |x| ≤ 1.
? If the result is 1:
- Return -1.
Else:
$ Execute the monadic chain formed by the two links to the left.
Æl Apply natural logarithm to x.
ß Recursively call the main link.
‘ Increment the result.
```
[Answer]
# MATLAB / Octave, 44 bytes
`function a=g(n);a=0;if n>1;a=1+g(log(n));end`
Tried to do it all as one anonymous function, but I forgot that MATLAB/Octave continues to evaluate expressions even if they are multiplied by a boolean false (zero) value:
`f=@(n)(n>1)*(1+f(log(n)))`
[Answer]
**Mathematica, 29 bytes**
Simple as all hell, and works for comically large as well as negative inputs:
```
f[x_]:=If[x>1,1+f[Log[x]],0]
```
[](https://i.stack.imgur.com/RQW7W.png)
[Answer]
# R, ~~38~~ 37 bytes
```
f=function(x)if(x>1)1+f(log(x))else 0
```
Thanks [@user5957401](https://codegolf.stackexchange.com/users/58162) for the extra byte!
Test cases:
```
> f(0)
[1] 0
> f(1)
[1] 0
> f(2)
[1] 1
> f(3)
[1] 2
> f(4)
[1] 2
> f(3814279)
[1] 3
> f(3814280)
[1] 4
```
[Answer]
# [R](https://www.r-project.org/), 34 bytes
```
f=pryr::f(`if`(n>1,1+f(log(n)),0))
```
[Try it online!](https://tio.run/##K/r/P822oKiyyMoqTSMhMy1BI8/OUMdQO00jJz9dI09TU8dAU/N/moaBJleahiGIMAIRxmCuKZg0AwtYGJoYmVvCmRYGmv8B "R – Try It Online")
A non-recursive approach is possible: **36** bytes and takes input from stdin.
```
n=scan()
while((n=log(n))>0)F=F+1
+F
```
[Answer]
## Emacs Lisp, 38 bytes
```
(defun l(n)(if(> n 1)(1+(l(log n)))0))
```
Testcases:
```
(mapcar 'l '(0 1 2 3 4 15 16 3814279 3814280))
;; (0 0 1 2 2 2 3 3 4)
```
[Answer]
## Perl 5, 35 bytes
Very simple, requires `-M5.016` (which is free) to enable the `__SUB__` keyword for anonymous recursion.
```
sub{$_[0]>1?1+__SUB__->(log pop):0}
```
Another alternative is
```
sub{$_[0]>1?1+__SUB__->(log pop):0}
```
which is 34 bytes, and gives the same output for all inputs > 1, but returns the special false value for inputs <= 1. False is numerically equal to zero, but prints as "" (empty string), so it probably doesn't qualify.
[Answer]
## CJam (16 bytes)
```
rd{_1>}{_ml}w],(
```
[Online demo](http://cjam.aditsu.net/#code=rd%7B_1%3E%7D%7B_ml%7Dw%5D%2C(&input=3814280)
Simple while loop with pre-condition. (What I really want here is a Golfscript-style unfold operation, but CJam doesn't have one, and floating point in GolfScript is messy and not at all golfy).
[Answer]
# [PARI/GP](http://pari.math.u-bordeaux.fr/), 24 bytes
Just the straightforward recursion.
```
f(n)=if(n>1,1+f(log(n)))
```
[Answer]
# Racket, 61 bytes
```
(λ(x)(letrec([a(λ(b)(if(> b 1)(+ 1 (a(log b)))0))])(a x)))
```
[Answer]
# Maple, ~~32,30~~ 29 bytes
```
f:=x->`if`(x>1,1+f(log(x)),0)
```
Test cases:
```
> f(0.);
0
> f(1.);
0
> f(2.);
1
> f(3.);
2
> f(4.);
2
> f(3814279.);
3
> f(3814280.);
4
```
[Answer]
# R, 36 bytes
Slightly different approach from Plannapus
```
->n;a=0;while(n>1){a=a+1;n=log(n)};a
```
Uses a right assign to run the code -- so the desired number must precede it. i.e.
```
10->n;a=0;while(n>1){a=a+1;n=log(n)};a
```
[Answer]
# [Whispers v3](https://github.com/cairdcoinheringaahing/Whispers), 9 bytes
```
>> ln*(L)
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fzk4hJ09Lw0fzv52CZ15BaQkXUMTwUccMIxDDv7QEKKRg/N/YwtDEyMIAAA "Whispers v2 – Try It Online")
Note that I had to [push a bug fix](https://github.com/cairdcoinheringaahing/Whispers/commit/9fb12f3ba8a5e1a7611fae2dfae5c9938345255e) in order to make this work. The `ln*` function had already been added [before September 1st 2020](https://github.com/cairdcoinheringaahing/Whispers/blob/81c0e41e8fe10fabfde713072cc6cd5e0e49290e/whispers%20v3.py#L2546), but I hadn't noticed a bug in the parsing that was fixed today
This is a function, going by the standards defined [here](https://codegolf.meta.stackexchange.com/a/20740/66833) for Whispers functions. It can be called by appending the code in the Footer to the file.
Whispers v3 also has the `slog`, `lg*` (uses \$\log\_2\$) and `log*` (uses \$\log\_{10}\$) functions
[Answer]
### Ruby, 29 bytes
```
l=->n{n<=1?0:1+l[Math.log n]}
```
[Answer]
# [Perl 6](http://perl6.org/), 21 bytes
```
{($_,*.log...1>=*)-1}
```
[Try it online!](https://tio.run/##JcVLDkAwFAXQrdxIIwgvnm@FdiuNgZoQwqgpa6@BMznncm1d2B1iCxV8Ikye0XasRMRaZWnBb7hnh0gYKA1vIcwbwR4XnqQkatIcz8QtuEMtuan64V@Wegwf "Perl 6 – Try It Online")
The parenthesized expression is a sequence. `$_`, the argument to the function, is the first element. `*.log` generates each successive element by taking the log of the previous element. The sequence continues until the ending condition, `1 >= *`, is true: 1 is greater than or equal to the current element. Subtracting 1 from the sequence coerces it to a number: its length.
] |
[Question]
[
**This question already has answers here**:
[Case Permutation](/questions/80995/case-permutation)
(24 answers)
Closed 6 years ago.
For any String that is composed of lower cased alphabetical characters, make a function that returns a list of all of it's variations, empty strings returns empty list
**Test Cases**
```
"" -> []
"a" -> ["a", "A"]
"ab" -> ["ab", "Ab", "aB", "AB"]
"abc" -> ["abc", "Abc", "aBc", "ABc", "abC", "AbC", "aBC", "ABC"]
```
This is Code-golf. Shortest code in bytes wins
[Answer]
## JavaScript (Firefox 30-57), 75 bytes
```
f=([c,...s])=>c?[for(t of s[0]?f(s):[''])for(d of c+c.toUpperCase())d+t]:[]
```
67 bytes if the empty string returns `[""]`:
```
f=([c,...s])=>c?[for(t of f(s))for(d of c+c.toUpperCase())d+t]:['']
```
] |
[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/148766/edit).
Closed 6 years ago.
[Improve this question](/posts/148766/edit)
I got inspired by this: [Print every character your program doesn't have](https://codegolf.stackexchange.com/questions/12368/print-every-character-your-program-doesnt-have)
But with the exception that the letters have to be between ASCII 32 to 126. We started fooling around with it at the office with PHP and this is the best we could come up with:
`<? while($i++<95)if(!strstr(file(__FILE__)[0],$a=chr($i+31)))echo$a;`
Is it possible to make it even shorter with PHP?
]
|
[Question]
[
**This question already has answers here**:
[Reverse stdin and place on stdout](/questions/242/reverse-stdin-and-place-on-stdout)
(140 answers)
Closed 6 years ago.
This is a pretty simple one. if the user enters "Hello World" your code should output "dlroW olleH"
I was inspired by the multiplication question recently posted. I know this is probably easy in bash.
As this is code-golf, least bytes wins.
[Answer]
# Mathematica, 13 bytes
```
StringReverse
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n6Zgq/A/uKQoMy89KLUstag49X8AkFOi4JAWreSRmpOTrxCeX5STohT7HwA "Wolfram Language (Mathematica) – Try It Online")
] |
[Question]
[
**Challenge:**
Write the smallest program (in characters) that resolves quadratic equations
i.e. `ax² + bx + c = 0`
**Rules:**
Given 3 numbers in **R** comma-delimited on STDIN: a,b,c (a != 0),
print on STDOUT the 2 roots in **C**, one per line.
**R** stands for real numbers, **C** for complex numbers.
**Examples:**
```
Input Output
1,0,0 r1=0 also accepted: r1=(-0-sqrt(0))/2
r2=0
1,2,1 r1=-1 also accepted: r1=(-2-sqrt(0))/2
r2=-1
1,1,1 r1=(-1-isqrt(3))/2 also accepted: r1=(-1-sqrt(-3))/2 or r1=-0.5-0.866i
r2=(-1+isqrt(3))/2
```
[Answer]
**R, 19 chars**
```
polyroot(scan(n=3))
```
or more strictly following the I/O requirements in 58 chars:
```
r=polyroot(rev(scan(sep=",")));cat("r1=",r[1],"\nr2=",r[2])
```
edit: reversed coefficients
[Answer]
# J, 21
J's got a verb to do exactly that: `p.` It does complex to complex, but your problem is a subset of that.
```
echo"0>{:p.|.".1!:1[3
```
As always with J solutions here, I/O and formatting take up 90% of the solution.
[Answer]
## Python 3, 79 chars
```
a,b,c=eval(input())
d=(b*b-4*a*c)**.5/2/a
x=-b/2/a
print('r1=',x+d,'\nr2=',x-d)
```
Python's imaginary unity is `j` and not `i`. I used Python 3 because the power operator works also on negative numbers.
BTW, is it really needed to write `r1= ...` and `r2= ...` ?
[Answer]
## Perl, 96 87 Characters
```
($a,$b,$c)=eval<>;$_=abs($_=$b*$b-4*$a*$c)**.5/2/$a.i x($_<0);$b/=-2*$a;die"r1=$b+$_
r2=$b-$_"
```
The line break is intentional, as is a space.
Edit: By reformatting output, I can shorten this to:
```
($a,$b,$c)=eval<>;$_="sqrt(".($b*$b-4*$a*$c)."))/".2*$a;$b*=-1;die"r1=($b+$_
r2=($b-$_"
```
[Answer]
## Perl, 76 characters (+1 command line switch)
```
perl -pe '($a,$b,$c)=eval;$d=($b/=-$a)**2-4*$c/$a;$_="-+";s!.!r@+=($b$&sqrt($d))/2\n!g'
```
Replacing the `\n` with a literal newline allows a further trivial one-character reduction.
Sample input / output:
```
1,0,0
r1=(0-sqrt(0))/2
r2=(0+sqrt(0))/2
1,2,1
r1=(-2-sqrt(0))/2
r2=(-2+sqrt(0))/2
1,1,1
r1=(-1-sqrt(-3))/2
r2=(-1+sqrt(-3))/2
1,0,-1
r1=(0-sqrt(4))/2
r2=(0+sqrt(4))/2
2,1,1
r1=(-0.5-sqrt(-1.75))/2
r2=(-0.5+sqrt(-1.75))/2
```
Yeah, it's not exactly Wolfram Alpha, but I believe it should qualify as acceptable output.
[Answer]
## D (160 chars)
```
import std.complex;import std.stdio;void main(){real a,b,c;readf("%f,%f,%f",&a,&b,&c);Complex!real j=sqrt(b*b-4*a*c)/2/a,i=-b/2/a;write("r1=",i+j,"\nr2=",i-j);}
```
[Answer]
# Perl, 101 chars
First stab:
```
perl -E 'my($x,$y,$z)=pop=~/\d+/g;printf"r%d=(%+d%ssqrt(%d))/%d\n",++$p,-$y,$_,$y**2-4*$x*$z,2*$x for qw/- +/;' 1,2,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/138144/edit).
Closed 6 years ago.
[Improve this question](/posts/138144/edit)
Inspired by [this](https://codegolf.stackexchange.com/questions/138124/can-i-burn-the-farmers-too?noredirect=1&lq=1), [this](https://codegolf.stackexchange.com/questions/138108/will-i-make-it-out-in-time?noredirect=1&lq=1) and [this](https://codegolf.stackexchange.com/questions/138068/kill-it-with-fire?noredirect=1&lq=1).
So, now that the [evil farmer](https://codegolf.stackexchange.com/questions/138068/kill-it-with-fire?noredirect=1&lq=1) has set your field on fire, you naturally want to put it out. You have a bunch of friends who all have buckets, and you want a program to figure out where to place everyone to save as much of your wheat as possible.
## Your Task:
Write a program or function that takes as arguments the field, and the number of friends with buckets you have, and outputs the field with the optimal placement of friends with buckets. The field will be represented by either a string, an array of strings, an array of arrays of characters, or any other method you deem appropriate. The field consists of numbers representing how intense the fire is. A 0 indicates that an area is not on fire. 1-4 represents the fire growing in intensity. When the fire reaches stage 4, it spreads fires to all directly (not diagonally) adjacent areas that are not adjacent (directly or diagonally) to a bucket brigadier. After stage 4, the fire dies, and becomes an "A", representing ashes. In your output, friends with buckets are represented by a B. They may be placed anywhere that does not contain flames. When a friend is placed, any flames adjacent to them go out.
## Input:
An integer representing the number of friends with buckets available, and an array or string representing the field.
## Output:
The field, with friends placed to optimise the amount of wheat saved. If you use a different set of characters than mentioned above, please include that information in your answer.
## Test Cases:
```
1, 1001 10B0
000000000 -> 000000000
000000 000000
2, 1000000000010000101 100000000001B000101 Note that the friend on the second line could be placed in many other locations.
00000000000000 -> 0000B000000000
00000000 00000000
00000000 00000000
```
## Scoring:
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest solution in bytes wins!
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 6 years ago.
[Improve this question](/posts/136904/edit)
I saw **Tom Scott's** video on **FizzBuzz** *<https://www.youtube.com/watch?v=QPZ0pIK_wsc>*
so I felt to write my own more "complex" version,this is what I came up with, its very flexibly and easy to scale, and its easy to add more if cases that can trigger functions.
**"The challenge":** Write a semi-compact "complex FizzBuzz" that can scale handle to "unlimited" if cases, ex. if multiple of 3 do A if multiple of 5 do B of multiple of 3 and 5 do C, if multiple of 3,5,7 and 11 do D etc.
**Code(C# console application):**
```
// FizzBuzz
// Patrik Fröher
// 2017-07-31
using System;
using System.Collections.Generic;
namespace fizzBuzz
{
class Program
{
static string isM(int i, int m)
{
if (i % m == 0) { return ("1"); }
return "0";
}
static void Main(string[] args)
{
List<string> tmp = new List<string>();
bool loop = true;
int i = 1;
string m3;
string s3 = "Fizz";
string m5;
string s5 = "Buzz";
string m7;
string s7 = "Fuzz";
string m11;
string s11 = "Biff";
string m13;
string s13 = "Buff";
string mm;
while (loop)
{
m3 = isM(i, 3);
m5 = isM(i, 5);
m7 = isM(i, 7);
m11 = isM(i, 11);
m13 = isM(i, 13);
mm = (m3 + m5 + m7 + m11 + m13);
switch (mm)
{
case "00000": tmp.Add(i.ToString()); break;
case "10000": tmp.Add(s3); break;
case "01000": tmp.Add(s5); break;
case "11000": tmp.Add(s3 + s5); break;
case "00100": tmp.Add(s7); break;
case "00010": tmp.Add(s11); break;
case "00110": tmp.Add(s7 + s11); break;
case "00001": tmp.Add(s13); break;
case "11111": tmp.Add("Patan77.com"); loop = false; break;
}
i++;
}
Console.SetBufferSize(Console.BufferWidth, (tmp.Count + 1));
tmp.ForEach(Console.WriteLine);
}
}
}
```
]
|
[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/135284/edit).
Closed 6 years ago.
[Improve this question](/posts/135284/edit)
# Challenge
HP is doing research in mathematics . After doing lots of research, she struck in a problem . She found four numbers n,a, b and c .Now, She wants to know how many number exists which are less than or equal to n and are divisible by a ,b or c .
# Input :
4 integers denoting `n,a,b and c` separated by space
# Output :
intger which denotes the count of the numbers which are divisible `a,b,c`
## Scoring:
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest code in bytes wins.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~72~~ 65 bytes
*Note:* This solution works for *positive* integers:
```
lambda a,b,c,n:len([x for x in range(1,n+1)if x%a*(x%b)*(x%c)<1])
```
[Try it online!](https://tio.run/##FcTBDkAwDADQX@lFstKDOogIX4JDh7GEksVhvn7iHd79PvulVXL9mA457SIgZGkmbY9VzRDBXQEieIUguq2GSQtG7yBmkpuYWfyfseMJ0x28PuBMTQ1xSVxh@gA "Python 2 – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 52 bytes
```
lambda n,a,b,c:n/a+n/b+n/c-n/a/b-n/a/c-n/b/c+n/a/b/c
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSFPJ1EnSSfZKk8/UTtPPwmIk3WBbP0kMAliJ@kna4NF9JP/FxRl5pUopGkYGumY6VjoGBpo/gcA "Python 2 – Try It Online")
By the [inclusion–exclusion principle](https://en.wikipedia.org/wiki/Inclusion%E2%80%93exclusion_principle).
] |
[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/133709/edit).
Closed 6 years ago.
[Improve this question](/posts/133709/edit)
>
> *No, not that thing in powerpoint*
>
>
>
You will be given a string, and a 2D array of boolean values. The 2D array will represent a picture.
You will be creating art out of it.
Let me show you how.
# The steps to art
First, you create a square which fits the 2d array, with the string.
Like if the string is 'PPCG', and the picture is 4x3, the square should be like this.
```
PPCG
PCGP
CGPP
GPPC
```
Now in the square, erase all characters which the corresponding boolean is 0, or the corresponding boolean doesn't exist.
Let me show you. If the 2D array is
```
1001
0110
1001
```
And the square is same to the above (above this one), the result should be like:
```
P G
CG
C P
```
Now output the result.
# Test data is not made yet. Will add ASAP.
# Rules
* General [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply, including loopholes.
[Answer]
# Mathematica, 74 bytes
```
(z=Characters@#;Grid[Table[RotateLeft[z,i],{i,0,Length@#2-1}]#2/.0->" "])&
```
**input**
>
> ["PPCG", {{1, 0, 0, 1}, {0, 1, 1, 0}, {1, 0, 0, 1}}]
>
>
>
works for test case.will update if things get "clearer"...
[Answer]
# C#, 168 bytes
```
s=>a=>{var r=new string[a.Length];for(int i=0,j;i<a.Length;++i)for(j=0;j<a[i].Length;++j)r[i]+=a[i][j]>48?(s.Substring(i,s.Length-i)+s.Substring(0,i))[j]:' ';return r;}
```
Works for the example in the question, not entirely sure how it will hold up against future test cases as the spec isn't fully clear.
[Try it online!](https://tio.run/##dVHLasMwELz7KwZfImHH2NBDqRP3EGihpBCaQw@OD6qjpDKJBJKSUoK/3ZXtPGk7B2m1O7MvlWa4VVI1TblhxmDmHTw4GMusKLFXYolXJiShnbsPtph/G8u30dNOliNjtZDr8A9fXoQ4WVmGFcYwGGdg7jinuiRtsWca2vEk/zpJWTTlcm0/i/SGuVIaREgL4ehxiCp11ggndoogEPRGcVZVrSJF1dJzUVwpqt@KFtqxEIw7dl4VyHB3j0cQE813H32bRLhZj5kwhKAIcB12HQpKW/EDBhik3k0hze1OS@jLiPUV47jZiZJGbXj0roXlUyE56XNHL8p9kb@QfogV8WezybNPidtgXuAAP4njxEX8OEni9u7eqCml/5d442zZVaB9R7VXN80P "C# (Mono) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~95~~ ~~79~~ 74 bytes
*-2 bytes thanks to @Mr.Xcoder*
```
lambda s,b,e=enumerate:[[b*(2*s)[k+i]or' 'for k,b in e(v)]for i,v in e(b)]
```
[Try it online!](https://tio.run/##NYgxC8IwEEb/ym1J6g2tbkInB9fu5w0JXjDUJiWNBX99jIg8eHzvW9/lkeKp@vFWn3ZxdwsbOpRR4muRbIuciVynj91maD4ETlmB8inDjA5CBNG74W8H3H/tDNc1h1i012qaLleFRAP2jYGRmht9W/@Pjakf "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/125546/edit).
Closed 6 years ago.
[Improve this question](/posts/125546/edit)
The objective of this programming puzzle is to reproduce the following gif.
[](https://i.stack.imgur.com/PTRvV.gif)
Simplification: If you notice the geometric figures don't exactly touch each other. I think it's simpler if you make each vertex to touch the respective edge, and not to go beyond it. I'm not sure though of how this will alter the configuration of the balls movement.
Specifications: Sizes, colours, etc. Make them to your heart's content. But let's just be reasonable. I would prefer if the velocity of the balls was slower than that in the gif.
For those who are having a harder time understanding the picture, we begin with a triangle (3 sides), then a square(4sides), then a pentagon(5sides), and so on... until an pentadecagon (15 sides).
Wining condition: Smallest solution wins.
Berserker Mode: Do the gif by adding a third dimension...
]
|
[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/122179/edit).
Closed 6 years ago.
[Improve this question](/posts/122179/edit)
Jarl Olaf lives in a beautiful village, Stackholm. In every year he is thinking about raiding a place to get some golden jewelery, food and ~~programmers~~ ~~woman~~ slaves.
He is a good person but not the brightest one, so you need to help him decide the next target. He has three targets in his mind: Jarl Burg, England and Paris.
Jarl Burg is the closest, he lives In Norway, Olaf can sail there all year.
England is a longer journey, it will took him 2 months, but he wants to settle down a bit, so he must start his journey three month before winter and he also won't start it in winter.
Paris is far-far away, to sail there will took 3 months, need more man, more time to settle down, so 5 months before winter they need to be on the sea, but won't start in winter.
**Challenge**
Your task is to get the starting month as an input (string or number you decide) and decide where to sail. If more possible targets crossing each other then decide randomly where to go.
Your output will be the army of the ships. (3-6-9 ships)
**Help**
Olaf need only 3 ships to Jarl Burg, 6 to England and 9 to Paris.
1 ship is 2 tab long, the arragement of the ships are provided in the test cases for all three possibilities.
The second ships starts where the first ends, the third one start in the middle of the first and there is a new line between the second and the third ships.
The direction of the oars are significant.
Winter month are January (1), February (2), December (12).
**Test cases**
**Input:**
6
**Output:**
```
/ / / / / /
<■■■■■■» <■■■■■■»
\ \ \ \ \ \
/ / / / / /
<■■■■■■» <■■■■■■»
\ \ \ \ \ \
/ / /
\ \ \ <■■■■■■» \ \ \
<■■■■■■» \ \ \ <■■■■■■»
/ / / / / / / / /
<■■■■■■»
\ \ \
\ \ \
<■■■■■■»
/ / /
```
**Input:**
December
**Output:**
```
/ / /
<■■■■■■»
\ \ \
/ / /
<■■■■■■»
\ \ \
\ \ \
<■■■■■■»
/ / /
```
**Input:**
8
**Output:**
```
/ / /
<■■■■■■»
\ \ \
/ / /
<■■■■■■»
\ \ \
/ / /
\ \ \ <■■■■■■»
<■■■■■■» \ \ \
/ / / / / /
<■■■■■■»
\ \ \
\ \ \
<■■■■■■»
/ / /
```
This is code-golf challenge, so the answer with the fewest bytes wins.
]
|
[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/117548/edit).
Closed 6 years ago.
[Improve this question](/posts/117548/edit)
**Circa 1976**. With the success of the [*Tiny BASIC Design Note*](http://www.ittybittycomputers.com/IttyBitty/TinyBasic/DDJ1/Design.html), a variety of Tiny BASIC IL implementations now span a range of microcomputers. The time has come to expand the Tiny BASIC standard.
Grammar revisions:
```
(LET) var = expression
INPUT (string ,) var-list
PRINT expr-list (;)
IF expression relop expression (THEN) statement
DO
WHILE expression
UNTIL expression
REM any-text
```
Please rewrite the Tiny BASIC program in its IL to support the revised grammar above:
1. Make the “LET” keyword optional (prevent overbyte! e.g., X = X + 1 no longer has to be LET X = X +1).
2. Make the “THEN” keyword optional (e.g., IF X=21 PRINT “BLACKJACK!” becomes valid).
3. Support the “REM” remark statement for those people who upgraded their RAM and can waste memory with comments.
4. If an INPUT statement starts with a string, output that string as a prompt (e.g., INPUT “AGE?”, A).
5. If a PRINT statement ends with a semicolon (“;”) then suppress the carriage return.
6. Implement a DO-WHILE loop.
7. Implement a DO-UNTIL loop.
Sample loop:
```
10 X=10
20 DO
30 PRINT X
40 X=X-1
50 UNTIL X<0
60 REM "WHILE X>=0" WOULD ALSO HAVE WORKED
70 PRINT "BLASTOFF!"
```
I've lightly edited the [Tiny BASIC IL Reference and program here](https://docs.google.com/document/d/1xOsMd2O07Y242vuJ40RUSDWJTXqyfHIGM230baVJuc0/edit?usp=sharing) to make both easier to follow.
This is [atomic-code-golf](/questions/tagged/atomic-code-golf "show questions tagged 'atomic-code-golf'") so shortest code wins, but - since no one has an IL assembler handy and since encoding of op-codes varied anyway - in this case, the **fewest lines of code** wins (not counting blank lines or lines with only comments; no penalty here for readability).
]
|
[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/117320/edit).
Closed 6 years ago.
[Improve this question](/posts/117320/edit)
# Background:
Okay, i dropped my android smartphone and damaged the touchscreen
The lower half (yeah, exact half!) is spider-webbed and does not work (potrait-mode)
Fortunately for me, the display itself is working
My phone is already rooted and adb enabled, so i have managed to enable 360 degree display rotation
Using this phone almost appeared to be an excercise in frustration, having to rotate the phone this way and that, in order to touch/tap/swipe the inaccessible screen estate
But I've gotten pretty good at it now
```
T O P
_ _^_ _
| |
| |
|_ _ _ _|
| / / / |
|/ / / /|
|_/_/_/_|
_ _ _ _ _ _
|/ / /| | T
| / / | |\ O
|/ / /| |/ P
|_/_/_|_ _ _|
```
Code Golf Challenge:
Given the current screen orientation and the desired (Row,Column) coordinate to touch, find the optimal rotation to access the point - direction and count
# Assumptions:
* This challenge is only for the App icons in the App Drawer, assume that the screen always shows the full grid of Apps and nothing else
* Size of the grid is 6 Rows X 4 Columns in portait mode
* Apps fill only one page in the App drawer - total number of apps is 24
* Screen orientation can have four possible values - 0,90,180,270
0 - Normal Potrait
90 - Landscape achieved by turning the phone counter-clock-wise
180 - Reverse Potrait achieved by turning the phone counter-clock-wise
270 - Reverse Landscape achieved by turning the phone counter-clock-wise
* Input will always be in the format (Row,Column,Current Orientation), including parantheses and commas with no spaces
Counting starts from 1
Note that the coordinates are WYSIWYG - meaning, the Row number and column number are with respect to the current orientation
Ex: (2,5,270)
Which is Row 2, Column 5 while in Landscape
```
_ _ _ _ _ _
T | |/ / /|
O/| | /?/ |
P\| |/ / /|
|_ _ _|_/_/_|
```
# Rules:
* Standard Loopholes apply
* Output may contain newlines
* If the there are two equally optimal outcomes for a given input, both must be output by the code, sorted by clock-wise outcome first
* Output should be in the format (Direction of rotation,Number of 90 degree turns), including parantheses and commas with no spaces
Ex: (C,2)
(CC,1)
* If the current orientation is the optimal choice for a given input, the code should output 0
* Shortest code wins!
# Test cases:
```
#1
Input: (2,3,270)
Output: 0
#2
Input: (3,3,90)
Output: (C,1)
```
Will add more when i get time!
This is my first code-golf challenge, questions and suggestions welcome
Happy golfing!
]
|
[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/117015/edit).
Closed 6 years ago.
[Improve this question](/posts/117015/edit)
The following puzzle was asked in [puzzling SE](https://puzzling.stackexchange.com/questions/51144/self-referential-puzzle-medium-2). This puzzle is quite hard to solve by hand because every answer depends on another answer. So, for example, a solution with all answers being A does not work because then the question 7 would contradict question 8, for example.
One of the answers there at puzzling SE suggested to write a program to test all possible answers and show one of them (if it exists). So, I'm bringing this to the experts :)
The puzzle consists in finding an array of ten characters (each one of them being either A, B, C, D or E) that satisfies all the following questions (where each character in the array is an "answer" and its index is a "question") **without contradiction**:
1. The first question whose answer is D is the question
>
> A. 8
>
> B. 7
>
> C. 6
>
> D. 5
>
> E. 4
>
>
>
2. Identical answers have questions
>
> A. 3 and 4
>
> B. 4 and 5
>
> C. 5 and 6
>
> D. 6 and 7
>
> E. 7 and 8
>
>
>
3. The number of questions with the answer E is
>
> A. 1
>
> B. 2
>
> C. 3
>
> D. 4
>
> E. 5
>
>
>
4. The number of questions with the answer A is
>
> A. 1
>
> B. 2
>
> C. 3
>
> D. 4
>
> E. 5
>
>
>
5. The number of questions with the answer A equals the number of questions with the answer
>
> A. A
>
> B. B
>
> C. C
>
> D. D
>
> E. none of the above
>
>
>
6. The last question whose answer is B is the question
>
> A. 5
>
> B. 6
>
> C. 7
>
> D. 8
>
> E. 9
>
>
>
7. Alphabetically, the answer to this question and the answer to the following question are
>
> A. 4 apart
>
> B. 3 apart
>
> C. 2 apart
>
> D. 1 apart
>
> E. the same
>
>
>
8. The answer to this question is the same as the answer to the question
>
> A. 1
>
> B. 2
>
> C. 3
>
> D. 4
>
> E. 5
>
>
>
9. The number of questions whose answers are consonants
>
> A. 3
>
> B. 4
>
> C. 5
>
> D. 6
>
> E. 7
>
>
>
10. The answer to this question is
>
> A. A
>
> B. B
>
> C. C
>
> D. D
>
> E. E
>
>
>
The objective of this chalenge is to write the **shortest program** that can **generate all the possible answers** and **check how many of them** (if any) satisfy what every one of the previous questions are asking (the output of the program would be the list of the answers that satisfy all the questions without contradiction).
The original test can be found [here](https://www.brainzilla.com/logic/self-referential-quiz/srq-2/) (although it is irrelevant for this chalenge).
[Answer]
# [Pyth](https://esolangs.org/wiki/Pyth), 104 bytes
```
f!s[nhd-8xd3@.+d+3@d1nh@d2/d4nh@d3/d0!&/3@d4!-/d0/d@d4!-10x_d1@d5n@d6a4@.+d6n@d7@d@d7!+3@d8@ds/LdS3)^U5T
```
It... uh... takes a while to run. [Try it online... if the server doesn't time out or run out of memory.](http://pyth.herokuapp.com/?code=f%21s%5Bnhd-8xd3%40.%2Bd%2B3%40d1nh%40d2%2Fd4nh%40d3%2Fd0%21%26%2F3%40d4%21-%2Fd0%2Fd%40d4%21-10x_d1%40d5n%40d6a4%40.%2Bd6n%40d7%40d%40d7%21%2B3%40d8%40ds%2FLdS3%29%5EU5T&debug=0)
Explanation coming SoonTM. Prints all the valid solutions as a 0-based list (ten elements long in which `A` is represented by `0`, `B` by `1`, and so on).
This is a naive solution that can probably be golfed a lot. Just wanted to get something out there.
] |
[Question]
[
Write a program (or function) that takes in a non-empty string of any [printable ASCII](https://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) characters.
Print (or return) a zigzagging chain of the characters in the string with every neighboring pair of characters linked by:
* `/` if the first character occurs before the second character in normal ASCII order. e.g.
```
B
/
A
```
* `\` if the first character occurs after the second character in normal ASCII order. e.g.
```
B
\
A
```
* `-` if the first and second characters are the same. e.g.
```
A-A
```
So the output for `Programming Puzzles & Code Golf` would be
```
o
/ \
r z-z o e G l
/ \ / \ / \ / \ / \
P o r m-m n u l s & C d f
\ / \ / \ / \ / \ / \ / \ /
g a i g P e
\ /
```
If there is only one character in the input string the output would just be that character.
Your program should treat , `/`, `\`, and `-` just the same as all other characters.
e.g. `-\//-- \ //-` should produce:
```
\
/ \
- /-/
/ \
- --- \ /-/
\ / \ / \
-
\
```
There should be no extraneous newlines in the output except for a single optional trailing newline. (Note that the empty line in the example just above holds the last space in the the string and is therefore not extraneous.) There may be trailing spaces on any lines in any arrangement.
**The shortest code in bytes wins.**
One more example - Input:
```
3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679
```
Output:
```
9 9 8 6 6
/ \ / \ / \ / \ / \
9 6 8 7 3 3 4 2 4 8 9 8-8
/ \ / \ / \ / \ / \ / \ / \
4 5 2 5 5 2 3-3 3 7 5 2 4 9 9 9-9 7
/ \ / \ / \ / \ / \ / \ / \ / \ / \
3 1 1 3 2 0 1 7 6 3 3 5 8 8 6
\ / \ / \ / \ / \ / \
. 1 1 5 2 9 9 3 7 1 4 6 8 9
\ / \ / \ / \ / \ / \ / \ / \ /
0 0 7 9 5 2 0 0 2 6 9-9 8 5 4 7
\ / \ / \ / \ / \ / \ / \ /
4 4-4 2 8 8 4 2 3 2 7 6
\ / \ / \ / \ /
0 6 8 3 1-1 0
\ / \ /
2 0
```
[Answer]
# Pyth, 69 bytes
```
aY,JhzZVtzaY,@"-\/"K-<NJ>N~JN=+ZKaY,N=+ZK;jbCmX*\ h-e=GSeMYhG-edhGhdY
```
[Demonstration.](https://pyth.herokuapp.com/?code=aY%2CJhzZVtzaY%2C%40%22-%5C%2F%22K-%3CNJ%3EN~JN%3D%2BZKaY%2CN%3D%2BZK%3BjbCmX*%5C+h-e%3DGSeMYhG-edhGhdY&input=++-%5C%2F%2F--+%5C+%2F%2F-+&debug=0) Longer inputs still work, but they don't look very good in the fixed-width output box.
I start by constructing a list, in `Y`, of [character, height] tuples. It is `[['P', 0], ['/', -1], ['r', -2], ['\\', -1], ['o', 0], ['\\', 1], ['g', 2]]` early on in the `Programming Puzzles & Code Golf` example.
I then make strings of spaces of the appropriate length, insert the character at the appropriate location, transpose, join on newlines and print.
[Answer]
# Julia, 297 bytes
```
s->(l=length;d=sign(diff([i for i=s]));J=join([[string(s[i],d[i]>0?:'/':d[i]<0?:'\\':'-')for i=1:l(d)],s[end]]);D=reshape([d d]',2l(d));L=l(J);E=extrema(cumsum(d));b=2sumabs(E)+1;A=fill(" ",L,b);c=b-2E[2];for (i,v)=enumerate(J) A[i,c]="$v";i<l(D)&&(c-=D[i])end;for k=1:b println(join(A'[k,:]))end)
```
Ungolfed:
```
function f(s::String)
# Get the direction for each slash or dash
# +1 : /, -1 : \, 0 : -
d = sign(diff([i for i in s]))
# Interleave the string with the slashes as an array
t = [string(s[i], d[i] > 0 ? '/' : d[i] < 0 ? '\\' : '-') for i = 1:length(d)]
# Join the aforementioned array into a string
J = join([t, s[end]])
# Interleave D with itself to duplicate each element
D = reshape(transpose([d d]), 2*length(d))
# Get the length of the joined string
L = length(J)
# Get the maximum and minimum cumulative sum of the differences
# This determines the upper and lower bounds for the curve
E = extrema(cumsum(d))
# Get the total required vertical size for the output curve
b = 2*sumabs(E) + 1
# Get the beginning vertical position for the curve
c = b - 2*E[2]
# Construct an array of spaces with dimensions corresponding
# to the curve rotated 90 degrees clockwise
A = fill(" ", L, b)
# Fill the array with the curve from top to bottom
for (i,v) = enumerate(J)
A[i,c] = "$v"
i < length(D) && (c -= D[i])
end
# Print out the transposed matrix
for k = 1:b
println(join(transpose(A)[k,:]))
end
end
```
[Answer]
# Javascript (ES6), ~~360~~ ~~331~~ ~~316~~ 302 bytes
Here's my fourth attempt:
```
s=>{r=[],c=s[m=w=n=0];for(i in s)(i?(d=s[++i])>c?++n:c>d?--n:n:n)<m&&m--,n>w&&w++,c=d;for(i=0,n=w*2;i<(w-m)*2+1;r[i++]=[...' '.repeat(l=s.length*2-1)]);for(i=0;i<l;i++)i%2?(A=s[C=(i-1)/2])<(B=s[C+1])?r[--n,n--][i]='/':A>B?r[++n,n++][i]='\\':r[n][i]='-':r[n][i]=s[i/2];return r.map(x=>x.join``).join`
`}
```
Not as short as some of the others, but I'm satisfied with it for now.
Oh, so you want to test it? Alright, here you go:
```
z=s=>{r=[],c=s[m=w=n=0];for(i in s)(i?(d=s[++i])>c?++n:c>d?--n:n:n)<m&&m--,n>w&&w++,c=d;for(i=0,n=w*2;i<(w-m)*2+1;r[i++]=[...' '.repeat(l=s.length*2-1)]);for(i=0;i<l;i++)i%2?(A=s[C=(i-1)/2])<(B=s[C+1])?r[--n,n--][i]='/':A>B?r[++n,n++][i]='\\':r[n][i]='-':r[n][i]=s[i/2];return r.map(x=>x.join``).join('<br>')};
input=document.getElementById("input");
p=document.getElementById("a");
input.addEventListener("keydown", function(){
setTimeout(function(){p.innerHTML = "<pre>"+z(input.value)+"</pre>";},10);
})
```
```
<form>Type or paste your text here: <input type="text" id="input"/></form>
<h3>Output:</h3>
<p id="a"></p>
```
Have fun!
### Updates:
**Update 1:** Golfed off 29 bytes with a variety of typical techniques.
**Update 2:** Golfed off 15 more bytes by building the string horizontally from the start, as opposed to building an array of the vertical strings and switching them around, which is what it did before.
**Update 3:** Saved 14 more bytes.
More golfiness coming soon!
[Answer]
# Python, 393 bytes
```
def z(n,h=[]):
for j in range(len(n)):h.append(sum(cmp(ord(n[i]),ord(n[i+1]))for i in range(j)))
h=[j-min(h)for j in h]
for y in range(max(h)*2+2):
s=""
for x in range(len(n)):
if h[x]*2==y:s+=n[x]
else:s+=" "
if x==len(n)-1:continue
c=" "
if h[x]<h[x+1]and h[x]*2==y-1:c="\\"
if h[x]>h[x+1]and h[x]*2==y+1:c="/"
if h[x]==h[x+1]and h[x]*2==y:c="-"
s+=c
print s
```
Run as:
`z("Zigzag")`
[Answer]
# JavaScript (ES6), 202
Using template strings. Indentation spaces and newlines not counted, except the last newline inside backticks that is significant and counted.
Usual note: test running the snippet on any EcmaScript 6 compliant browser (notably not Chrome not MSIE. I tested on Firefox, Safari 9 could go)
```
f=z=>
[...z].map(c=>
(d=0,x=w+c,p&&(
c<p?o[d=1,g='\\ ',r+=2]||o.push(v,v)
:c>p?(d=-1,g='/ ',r?r-=2:o=[v,v,...o]):x='-'+c,
o=o.map((o,i)=>o+(i-r?i-r+d?b:g:x),v+=b)
),p=c)
,v=w=' ',o=[z[p=r=0]],b=w+w)&&o.join`
`
Ungolfed=z=>
(
v=' ',o=[z[0]],r=0,p='',
[...z].map(c=>{
if (p) {
if (c < p) {
if (! o[r+=2])
o.push(v,v)
o = o.map((o,i)=>o+(i==r ? ' '+c : i==r-1 ? '\\ ' : ' '))
} else if (c > p) {
if (r == 0)
o = [v,v,...o]
else
r -= 2
o = o.map((o,i)=>o+(i==r ? ' '+c : i==r+1 ? '/ ' : ' '))
} else {
o = o.map((o,i)=>o+(i==r ? '-'+c : ' '))
}
v += ' '
}
p = c
}),
o.join`\n`
)
out=x=>O.innerHTML+=x+'\n'
test = [
"Programming Puzzles & Code Golf",
"-\\//-- \\ //- ",
"3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"]
test.forEach(t=>out(t+"\n"+f(t)))
```
```
<pre id=O></pre>
```
[Answer]
# CJam, 79 bytes
```
l__0=\+2ew::-:g_0\{+_}%);_$0=fm2f*_$W=)S*:E;]z{~\_)"/-\\"=2$@-E\@t@@E\@t}%(;zN*
```
[Try it online](http://cjam.aditsu.net/#code=l__0%3D%5C%2B2ew%3A%3A-%3Ag_0%5C%7B%2B_%7D%25)%3B_%240%3Dfm2f*_%24W%3D)S*%3AE%3B%5Dz%7B~%5C_)%22%2F-%5C%5C%22%3D2%24%40-E%5C%40t%40%40E%5C%40t%7D%25(%3BzN*&input=%20%20-%5C%2F%2F--%20%5C%20%2F%2F-%20)
This builds the output column by column, and transposes the result at the end to get the output row by row. This was quite painful overall.
Explanation:
```
l__ Get input and create a couple of copies.
0=\+ Prepend copy of first letter, since the following code works only with
at least two letters.
2ew Make list with pairs of letters.
::- Calculate differences between pairs...
:g ... and the sign of the differences.
_0\ Prepare for calculating partial sums of signs by copying list and
pushing start value 0.
{ Loop for calculating partial sums.
+_ Add value to sum, and copy for next iteration.
}% End of loop for partial sums. We got a list of all positions now.
); Pop off extra copy of last value.
_$0= Get smallest value.
fm Subtract smallest value to get 0-based positions for letters.
2f* Multiply them by 2, since the offsets between letters are 2.
_$W= Get largest position.
) Increment by 1 to get height of result.
S* Build an empty column.
:E; Store it in variable E.
] We got the input string, list of relative offsets, and list of
absolute positions now. Wrap these 3 lists...
z ... and transpose to get triplets of [letter offset position].
{ Loop over triplets.
~ Unwrap triplet.
\ Swap offset to front.
_) Copy and increment so that offset is in range 0-2.
"/-\\" List of connection characters ordered by offset.
= Pick out connection character for offset.
2$@ Get position and copy of offset to top.
- Subtract to get position of connection character.
E Empty column.
\@ Shuffle position and character back to top. Yes, this is awkward.
t Place connection character in empty line. Done with first column.
@@ Shuffle letter and position to top.
E Empty column.
\@ Stack shuffling again to get things in the right order.
t Place letter in empty line. Done with second column.
}% End of main loop for triplets.
(; Pop off first column, which is an extra connector.
z Transpose the whole thing for output by row.
N* Join with newlines.
```
[Answer]
## Perl 5, ~~230~~ 214
```
@A=split(//,pop);$y=$m=256;map{$c=ord$_;$d=$c<=>$p;$t=$d>0?'/':$d<0?'\\':'-';$B[$x++][$y-=$d]=$t;$B[$x++][$y-=$d]=$_;$m=$y,if$m>$y;$M=$y,if$M<$y;$p=$c}@A;for$j($m..$M){for$i(1..$x){$s.=$B[$i][$j]||$"}$s.=$/}print$s
```
### Test
```
$ perl zigzag.pl "zigge zagge hoi hoi hoi"
z
\
i
\
g-g
\
e z g-g o o o
\ / \ / \ / \ / \ / \
a e h i h i h i
\ / \ / \ /
$
```
[Answer]
# K, 86
```
{-1@+((d#\:" "),'1_,/("\\-/"1+e),'x)@\:!|/d:(|/b)+-:b:1_+\,/2#'e:{(x>0)-x<0}@-':6h$x;}
```
.
```
k){-1@+((d#\:" "),'1_,/("\\-/"1+e),'x)@\:!|/d:(|/b)+-:b:1_+\,/2#'e:{(x>0)-x<0}@-':6h$x;} "Programming Puzzles & Code Golf"
o
/ \
r z-z o e G l
/ \ / \ / \ / \ / \
P o r m-m n u l s & C d f
\ / \ / \ / \ / \ / \ / \ /
g a i g P e
\ /
```
Ungolfed:
```
f:{
dir:{(x>0)-x<0}-':[*a;a:"i"$x]; //directional moves (-1, 0, 1)
chars:1_,/("\\-/"1+dir),'x; //array of input string combined with directional indicators
depths:(|/b)+-:b:1_+\,/2#'dir; //depth for each char, normalised to start at 0
-1@+((depths#\:" "),'chars)@\:!|/depths; //Pad each character by the calculated depths, extend each string to a uniform length and transpose
}
```
[Answer]
## Ruby, 158
Saved 6 bytes thanks to [histocrat](https://codegolf.stackexchange.com/questions/55593/zigzagify-a-string/55724?noredirect=1#comment137246_55724). Thanks!
```
->s,*i{i[x=n=k=(4*m=s=~/$/).times{i<<' '*m}/2][j=0]=l=s[/./]
$'.chars{|c|i[k-=d=c<=>l][j+1]=%w{- / \\}[d]
i[k-=d][j+=2]=l=c
n,x=[x,n,k].minmax}
puts i[n..x]}
```
[Answer]
## Python with Numpy: 218 bytes
It is worth it to waste 19 bytes for importing numpy.
Golfed:
```
from numpy import*
z=zip
r=raw_input()
s=sign(diff(map(ord,r[0]+r)))
c=cumsum(s)
p=2*(max(c)-c)+1
for L in z(*[c.rjust(i).ljust(max(p))for _ in z(z(p+s,array(list('-/\\'))[s]),z(p,r))for i,c in _][1:]):print''.join(L)
```
Ungolfed:
```
from numpy import *
letters = raw_input()
#letters = 'Programming Puzzles & Code Golf'
s = sign(diff(map(ord, letters[0] + letters)))
c = cumsum(s)
lines = array(list('-/\\'))[s]
letter_heights = 2 * (max(c) - c) + 1
line_heights = letter_heights + s
columns = [symbol.rjust(height).ljust(max(letter_heights))
for pair in zip( # interleave two lists of (height, symbol) pairs...
zip(line_heights, lines),
zip(letter_heights, letters)
)
for height, symbol in pair # ... and flatten.
][1:] # leave dummy '-' out
for row in zip(*columns):
print ''.join(row)
```
] |
[Question]
[
**This question already has answers here**:
[Josephus problem (counting out)](/questions/5891/josephus-problem-counting-out)
(31 answers)
Closed 7 years ago.
## Ninja Assassins - which ninja stays alive
**some basic information**
* given an int N as the number of ninjas, return the number of the winning ninja.
* At the end only 1 ninja survives,the question is which one? what was his number?.
* Each ninja kills the ninja who stands after him. Afterwards, he passes the sword to the first alive ninja who stood after the killed one.
## **Explenation - How the Game Works**
The ninjas are numbered from 1 to N and stand in a circle according to the numbers. The circle goes clockwise: ninja 2 is left to ninja 1, ninja 3 is left to ninja 2, ninja 4 is left to ninja 3.... ninja 1 is left to ninja N.
Ninja 1 gets a sword and the game begins:
Each ninja (starting from ninja 1) kills the closest and alive ninja he has to the left (clockwise) . Afterwards, he passes the sword to the 2nd closest and alive ninja he has to the left.The 2nd ninja does the same (kills and passes) (as an example: N=3(we have 3 ninjas), ninja 1 kills ninja 2 and gives the sword to ninja 3. Ninja 3 has ninja 1 as his closest and alive ninja to the left(clockwise - its a circle) so he kills ninja 1, stays the last ninja alive and wins (so the output\return is 3, as the number of the ninja)).
**A more detailed example below**
## Example - Word-detailed scenario
**N = 7 (we got 7 ninjas) :**
```
1 2 3 4 5 6 7 (L=alive, D=dead)
L D L L L L L The first ninja gets the sword and kills the 2nd ninja.
The first ninja passes the sword to the 3rd ninja.
L D L D L L L The 3rd ninja gets the sword and kills the 4th ninja.
The 3rd Ninja passes the sword to the 5th ninja.
L D L D L D L The 5th ninja gets the sword and kills the 6th ninja.
The 5th Ninja passes the sword to the 7th ninja.
D D L D L D L The 7th ninja gets the sword and kills the first(1st) ninja.
The 7th ninja passes the sword to the 3rd ninja.
D D L D D D L The 3rd ninja gets the sword and kills the 5th ninja.
The 3rd ninja passes the sword to the 7th ninja.
D D D D D D L The 7th ninja gets the sword and kills the 3rd ninja,
stays as the last one alive and wins (the final result /
the output is 7).
```
## More scenarios without words
**N=3 :** 1 2 3 - 1 3 - 3 wins
**N=4 :** 1 2 3 4 - 1 3 - 1 wins
**N=5 :** 1 2 3 4 5 - 1 3 5 - 3 5 - 3 wins
**N=6 :** 1 2 3 4 5 6 - 1 3 5 - 1 5 - 5 wins
**Scoring is based on the least number of bytes used, as this is a code-golf question.**
[Answer]
## Python 2, 30 bytes
```
lambda n:int(bin(n)[3:]+'1',2)
```
Takes the binary expansion of `n` and moves the initial `1` to the end.
[Answer]
## Python 2, 32 bytes
```
a=lambda n:n and(n%2+a(n/2))*2-1
```
---
**33 bytes:**
```
a=lambda n:n and 2*a(n/2)-(-1)**n
```
Uses the recursive formula on the [OEIS page](https://oeis.org/A006257).
* `a(2*n) = 2*a(n)-1`
* `a(2*n+1) = 2*a(n)+1`
[Answer]
## Java 7, ~~65~~ 53 bytes
```
int f(int n){return(n-Integer.highestOneBit(n))*2+1;}
```
Using the algorithm for k=2 Josephus from Wikipedia. Thanks to Leaky Nun for finding the builtin.
[Answer]
# Pyth, ~~22~~ ~~13~~ ~~12~~ 9 bytes
Credits to [Geobit's algorithm](https://codegolf.stackexchange.com/a/83820/48934) for saving 9 bytes. It works like magic.
Credits to [xnor's witchcraft](https://codegolf.stackexchange.com/a/83824/48934) for saving 3 bytes. It is simply witchcraft.
```
~~heu+G=Z%e.f!/G%ZQ2ZQQY~~
~~u?sIlH1+2GSQ1~~
~~hyaefgQT^L2~~
i.<.BQ1 2
```
[Test suite.](http://pyth.herokuapp.com/?code=i.%3C.BQ1+2&test_suite=1&test_suite_input=3%0A4%0A5%0A6%0A7&debug=0)
[Answer]
# Jelly, 4 bytes
Since xnor came up with [this algorithm](https://codegolf.stackexchange.com/a/83824/48934), I will make this community wiki.
```
Bṙ1Ḅ
```
[Try it online!](http://jelly.tryitonline.net/#code=QuG5mTHhuIQ&input=&args=Ng)
## Explanation
```
Bṙ1Ḅ
B convert to binary
ṙ1 left-rotate by 1
Ḅ convert from binary
```
[Answer]
# VBA, 57 67 bytes
Well, this technically ought to work (57 bytes):
```
Function Z(N):Z=2*(N-2^Int(Log(N)/Log(2)))+1:End Function
```
But actually, because occasionally the log value of a power of two is not quite an exact multiple of the log of 2, we need a few more bytes:
```
Function Z(N):Z=2*(N-2^Int(Log(N)/Log(2))):Z=1-Z*(Z<N):End Function
```
If there were a built-in binary converter, it would be much shorter.
The recursion version is a tie, basically, but needs a line-feed for the IF
```
Function Y(N):Y=1:If N>1 Then Y=2*Y(N\2)+2*(N\2=N/2)+1
End Function
```
[Answer]
# J, 10 bytes
```
(1&|.)&.#:
```
Using the formula where *a*(*n*) = *n* written in binary and rotated left by 1 place. Similar to what is used in @xnor's [solution](https://codegolf.stackexchange.com/a/83824/6710).
Using **19 bytes**, we can play the game according to the rules in the challenge.
```
[:(2&}.,{.)^:_>:@i.
```
This solution only performs array manipulation in order to reach a final player.
## Usage
Extra commands used for formatting multiple input/output with multiple functions.
```
f =: (1&|.)&.#:
g =: [:(2&}.,{.)^:_>:@i.
(,.f"0,.g"0) i. 10
0 0 0
1 1 1
2 1 1
3 3 3
4 1 1
5 3 3
6 5 5
7 7 7
8 1 1
9 3 3
```
## Explanation
```
(1&|.)&.#: Input: n
#: Convert to binary
( )&. Compose next function on the binary value
1&|. Rotate left by 1 place
( )&. Compose the inverse of the previous function on the result
#: The inverse: convert from binary to decimal and return result
[:(2&}.,{.)^:_>:@i. Input: n
i. Creates the range [0, 1, ..., n-1]
>:@ Increment each in the range to get [1, 2, ..., n]
[:( )^:_ Nest the function until the result does not change and return
2&}. Drop the first two items in the list
{. Get the head of the list
, Join them together. This makes it so that the head of the list
is always the current player and the one after the head is the
player to be removed
```
[Answer]
## Python, 29 bytes
```
f=lambda n:n&n-1<1or f(n-1)+2
```
Outputs 1 as `True` when `n` is a power of 2, checked by `n&n-1` being 0. Otherwise, outputs `2` higher than the previous value.
---
**28 bytes:**
Adapting [grc's general solution](https://codegolf.stackexchange.com/a/5895/20260) to the case `k=2` gives a better solution
```
f=lambda n:n and-~f(n-1)%n+1
```
Rather than explicitly checking for powers of `2`, it zeroes out the result before incrementing each time `f(n-1)` catches up to `n-1`
] |
[Question]
[
Let's play some code golf!
Given a tic-tac-toe board state (Example:)
```
|x|x|o|
|x|o|x|
|o|o|x|
```
Determine whether a game is a `win` a `lose` or `cat`. Your code should output any of these options given a state. The above game should output `lose`
Just to be clear: a win is defined as any 3 `x`s in a row (diagonal, horizontal, vertical). a lose is 3 `o`s in a row, while a `cat` game in none in a row.
To make things interesting, you get to determine your input structure for the state- which you must then explain. For instance `xxoxoxoox` is a valid state as seen above where each of the characters is read from left to right, top to bottom. `[['x','x','o'],['x','o','x'],['o','o','x']]` is the game in multidimensional array read in a similar way. While `0x1a9` which is hex for `110101001` might work as a suitable compression where `1` can be manipulated for `x`s and `0` can be manipulated for `o`.
But those are just some ideas, I'm sure you might have many of your own.
Ground rules:
1. Your program must be able to accept any viable state.
2. The form of input must be able to represent any state.
3. The input cannot be redundant, meaning each cell must only appear in one location.
4. "The win state must be determined from the board"
5. Assume a complete board
6. `Win` before `lose` for instance in the case 'xxxoooxxx'
Lowest character count wins
[Answer]
## Ruby 2.0, 85 characters
Here's a simple bitmask-based solution in Ruby:
```
d=gets.hex
$><<[292,146,73,448,56,7,273,84].map{|m|d&m<1?:lose:d&m<m ?:cat: :win}.max
```
The board is represented as a hex number, made up of nine bits corresponding to the nine squares. 1 is an `X`, 0 is an `O`. This is just like the `0x1a9` example in the question, though the `0x` is optional!
There's probably a better way to do the bitmasks then just hardcoding a big list. I'll happily take suggestions.
See it running [on Ideone here](http://ideone.com/91YLmq).
[Answer]
# Mathematica, 84 chars
```
a=Input[];Which[Max@#>2,win,Min@#<1,lose,1>0,cat]&@{Tr@a,Tr@Reverse@a,Tr/@a,Total@a}
```
Input format: `{{1, 1, 0}, {1, 0, 1}, {0, 0, 1}}`
[Answer]
# Bash: ~~283~~ ~~262~~ 258
Featuring a relatively friendly interface.
```
t(){ sed 's/X/true/g;s/O/false/g'<<<$@;}
y(){ t $(sed 's/X/Q/g;s/O/X/g;s/Q/O/g'<<<$@);}
f(){($1&&$2&&$3)||($1&&$5&&$9)||($1&&$4&&$7)||($2&&$5&&$8)||($3&&$5&&$7)||($3&&$6&&$9)||($4&&$5&&$6)||($7&&$8&&$9)}
f $(t $@)&&echo win||(f $(y $@)&&echo lose)||echo cat
```
To execute `bash tictactoe.sh O X O X O X X O X`
Note: the list of 9 positions is a standard matrix representation. It doesn't matter if the board is represented as column major or row major, read from left to right or top to bottom - games of noughts and crosses (or tic tac toe if you insist) are symmetrical, so input order should be irrelevant to the result in every correct implementation, as long as input is linear.
Edit: Thanks to h.j.k for shorter function syntax suggestion.
[Answer]
# Befunge 93 - 375
Takes a binary string as input.
```
99>~\1-:!!|>v
>0v>v>v >^$>v
^+ + + 0<:p:
>#+#+#+ ^246
^+ + + 0<265
>#+#+#+ ^pp6
^+ + + 0<2++
#+#+#+ 55p
0 0 552
>^>^>0v +46
v+ + + < ppp
>0 + + + v 444
v!!-3:<< 246
v_"ni"v ppp
0v" w"< :+:
\>,,,,@ 266
->,,,@ 555
!^"cat"_^ 645
!>:9-! ^ +:+
>| p:p
>"eso"v 6p6
@,,,,"l"< 246
p2p
>^
v <^ <
```
Reads the string. Bruteforce writes it (the right most vertical strip) as a matrix in between the
```
^+ + +
>#+#+#+
^+ + +
>#+#+#+
^+ + +
#+#+#+
```
adding lattice (idk). Determins the sum of the columns, rows, and two diagnals. Compares those values to 3 ("win") or 0 ("lose"), else if all the values equal 1 or 2 then draw ("cat").
[Answer]
# Python 2 - 214 bytes
```
b=eval(raw_input())
s=map(sum,b)
w,l='win','lose'
e="if min(s)<1:print l;a\nif max(s)>2:print w;a"
exec e+'\ns=map(sum,zip(*b))\n'+e
m=b[1][1]
for i in 0,2:
if m==b[0][i]==b[2][abs(i-2)]:print[l,w][m];a
print'cat'
```
I'm sure there are improvements to be made.
To run:
```
python2 tictactoe.py <<< '[[1,1,1],[1,0,1],[0,1,0]]'
```
which represents this board:
```
X|X|X
-----
X|O|X
-----
0|X|0
```
Exits with a `NameError` exception in every case except `cat`.
[Answer]
## Haskell, 146 chars
>
> To make things interesting, you get to determine your input structure for the state- which you must then explain.
>
>
>
OK :). My representation of a board is one of those 126 characters
>
> ĻŃŇʼnŊœŗřŚşšŢťŦŨųŷŹźſƁƂƅƆƈƏƑƒƕƖƘƝƞƠƤƳƷƹƺƿǁǂDždžLjǏǑǒǕǖǘǝǞǠǤǯDZDzǵǶǸǽǾȀȄȍȎȐȔȜȳȷȹȺȿɁɂɅɆɈɏɑɒɕɖɘɝɞɠɤɯɱɲɵɶɸɽɾʀʄʍʎʐʔʜʯʱʲʵʶʸʽʾˀ˄ˍˎː˔˜˭ˮ˰˴˼̌
>
>
>
Here's the solution in 146 chars :
```
main=interact$(\x->case(head x)of h|elem h "ĻŃœťŦŨųŷŹƁƂƅƈƕƠƤƳƿǂdžǞǤǵǾȀȳȿɁɅɑɒɘɝɠɤɵɽʀʐʽʾː˭ˮ˰˴˼̌"->"lose";h|elem h "ƏƝƞƹǁLjǑǝȍȺɆɈɶɾʎʸ"->"cat";h->"win")
```
And here's how it works, as an haskell script :
```
import Data.List (subsequences, (\\))
import Data.Char (chr)
-- A set of indexes [0-8] describing where on the board pieces of a single color have been played
-- For example the board "OxO;Oxx;xxO" is indexes [0,2,3,8]
type Play = [Int]
-- There are 126 filled tic tac toe boards when X plays first.
-- (This is a combination of 4 OHs among 9 places : binomial(9 4) = 126)
-- perms returns a list of all such possible boards (represented by the index of their OHs).
perms = filter (\x -> 4 == length x) $ subsequences [0..8]
-- We now create an encoding for plays that brings them down to a single char.
-- The index list can be seen as an 9 bit binary word [0,2,3,8] -> '100001101'
-- This, in turn is the integer 269. The possible boards give integers between 15 and 480.
-- Let's call those PlayInts
type PlayInt = Int
permToInt [] = 0
permToInt (x:xs) = (2 ^ x) + permToInt xs
-- Since the characters in the range 15-480 are not all printable. We offset the chars by 300, this gives the range
-- ĻŃŇʼnŊœŗřŚşšŢťŦŨųŷŹźſƁƂƅƆƈƏƑƒƕƖƘƝƞƠƤƳƷƹƺƿǁǂDždžLjǏǑǒǕǖǘǝǞǠǤǯDZDzǵǶǸǽǾȀȄȍȎȐȔȜȳȷȹȺȿɁɂɅɆɈɏɑɒɕɖɘɝɞɠɤɯɱɲɵɶɸɽɾʀʄʍʎʐʔʜʯʱʲʵʶʸʽʾˀ˄ˍˎː˔˜˭ˮ˰˴˼̌
-- Of all distinct, printable characters
uOffset = 300
-- Transform a PlayInt to its Char representation
pIntToUnicode i = chr $ i + uOffset
-- Helper function to convert a board in a more user friendly representation to its Char
-- This accepts a representation in the form "xooxxxoxo"
convertBoard s = let play = map snd $ filter (\(c, i) -> c == 'o') $ (zip s [0..]) :: Play
in pIntToUnicode $ permToInt play
--
-- Now let's cook some data for our final result
--
-- All boards as chars
allUnicode = let allInts = map permToInt perms
in map pIntToUnicode allInts
-- Now let's determine which boards give which outcome.
-- These are all lines, columns, and diags that give a win when filled
wins = [
[0,1,2],[3,4,5],[6,7,8], -- lines
[0,3,6],[1,4,7],[2,5,8], -- columns
[0,4,8],[2,4,6] -- diagonals
]
isWin :: Play -> Bool
isWin ps = let triplets = filter (\x -> 3 == length x) $ subsequences ps -- extract all triplets in the 4 or 5 moves played
in any (\t -> t `elem` wins) triplets -- And check if any is a win line
-- These are OH wins
oWins = filter isWin perms
-- EX wins when the complement board wins
xWins = filter (isWin . complement) perms
where complement ps = [0..9] \\ ps
-- And it's stalemate otherwise
cWins = (perms \\ oWins) \\ xWins
-- Write the cooked data to files
cookData = let toString = map (pIntToUnicode . permToInt) in do
writeFile "all.txt" allUnicode
writeFile "cWins.txt" $ toString cWins
writeFile "oWins.txt" $ toString oWins
writeFile "xWins.txt" $ toString xWins
-- Now we know that there are 48 OH-wins, 16 stalemates, and 62 EX wins (they have more because they play 5 times instead of 4).
-- Finding the solution is just checking to which set an input board belongs to (ungolfed :)
main = interact $ \x -> case (head x) of -- Only consider the first input char
h | elem h "ĻŃœťŦŨųŷŹƁƂƅƈƕƠƤƳƿǂdžǞǤǵǾȀȳȿɁɅɑɒɘɝɠɤɵɽʀʐʽʾː˭ˮ˰˴˼̌" -> "lose" -- This string is == oWins
h | elem h "ƏƝƞƹǁLjǑǝȍȺɆɈɶɾʎʸ" -> "cat" -- And this one == cWins
h -> "win"
```
[Answer]
## Ruby, 84 characters
```
$><<(gets.tr("01","10")[r=/0..(0|.0.)..0|000(...)*$|^..0.0.0/]?:win:~r ?:lose: :cat)
```
Simple, RegExp based solution. The input format is a 9-digit binary string, e.g. `110101001` for the example board given in the question.
## Ruby, 78 characters
```
$><<(gets.tr("ox","xo")[r=/o...(o|.o.)...o|ooo|o_.o._o/]?:win:~r ?:lose: :cat)
```
Input format: `xxo_xox_oox`
[Answer]
# Python3 - 188 w. different approaches to evaluation
Found the subject yesterday on Reddit and was fascinated. It was a simple code just to determine victory. Same night I made up my own version. Today i found this codegolf thread. [EDIT: 'blabla'] I am amazed about the different answers and possibilities within the other languages! Nice!
### 188 Python3 Code
EDIT: Now Meeting Requirements 1-5
Input-Style: Player p=0/1 and board b=(1,1,1,0,1,0,1,0,1)
```
def t(b,p):
s,c,l,w=0,"cat","loose","win"
for i in 1,2,3,4:
u=2*i-1
a=i*i-5*i+3
if b[4]==b[4+i]==b[4-i]:
if p==b[4]:s+=1
else:s-=1
if b[u]==b[u+a]==b[u-a]:
if p==b[u]:s+=1
else:s-=1
if s>0:c=w
if s<0:c=l
return c
```
## Victory Check Codes
### 103 Python3 - 'Square-Function'
EDIT1: nicer with "a==b==c==p" instead of "a+b+c==3\*p"
```
def t(b,p):
for i in 1,2,3,4:
u=2*i-1
a=i*i-5*i+3
if b[4]==b[4+i]==b[4-i]==p or b[u]==b[u+a]==b[u-a]==p:return True
```
Explanation: Term for a based on f(u=1)=f(u=7)=1 f(u=3)=f(u=5)=3
### 113 Python3 - 'Magic Square'
Input just with board: Player is „1“, Oponent „0“
```
def t(b):
n=[x*y for x,y in zip(b,(2,9,4,7,5,3,6,1,8))]
if 15 in [x+y+z for x in n for y in n if x!=y for z in n if z!=x and z!=y]:return True
```
Explanation: Sum has to be 15 in Magic Square
### 119 Python3 - 'Oneliner'
inspired by Reddit Solution from user 'Xelf'
```
def t(b,p):
if 3*p in [b[x]+b[y]+b[z] for x,y,z in [(0,1,2),(3,4,5),(6,7,8),(0,3,6),(1,4,7),(2,5,8),(0,4,8),(2,4,6)]]:return True
```
---
@Ad Hoc Garf Hunter Thank You for the Feedback! Though i am a bit embarassed and sorry i don´t even know what 'stdin' is about. Just want to contribute some ideas and learn. Thank you for the comment on assignment and whitespaces! I just corrected it.
EDIT: Hope to meet the rules now. I understand i could make spaces instead of tabs, but that just looks nasty.
[Answer]
## GolfScript, 63 + 27 = 90 bytes
I originally submitted the following 27-byte entry that exploited a loophole in the rules (as written at the time of submission) allowing a redundant input encoding:
```
70&.{~"win""lose"if}"cat"if
```
The input format for this entry is a string consisting of eight octal digits, each (redundantly) encoding three consecutive board squares:
* The first three digits each encode a single row of the board, from top down and left to right.
* The following three digits each encode a single column of the board, from left to right and top down.
* The final two digits each encode one of the diagonals (first from top left to bottom right, then from bottom left to top right).
To encode a sequence (row / column / diagonal) of three squares as an octal digit, replace every `x` in the sequence with a 1 and every `o` with a 0, and interpret the resulting sequence of ones and zeros as a binary number between 0 and 7 inclusive.
This input format is quite redundant (all board positions are encoded at least twice, with the center position encoded four times), but it *does* unambiguously represent any possible state of a completely filled tic-tac-toe board, and does not *directly* encode the winner into the input.
The input may, optionally, contain spaces or other delimiters between digits. In fact, all the program *really* cares about is whether or not the input string contains the digits `7` or `0`.
For example, the example board:
```
|x|x|o|
|x|o|x|
|o|o|x|
```
may be represented by the input:
```
651 643 50
```
To make testing the program above easier, I also provided a 63-byte GolfScript program to convert an ASCII art board layout, as shown above, into an input string suitable for this program:
```
."XOxo"--[{1&!}/]:a[3/.zip"048642"{15&a=}%3/]{{2base""+}%}%" "*
```
This converter ignores any characters other than `x` and `o`, in either case, in its input. It produces a single digit string (complete with space delimiters as shown above) suitable for feeding into the win-determining program above, so **the concatenation of these two programs can be used to determine the winner directly from the ASCII art board**, and thus still qualifies as a valid entry under the current challenge rules:
```
."XOxo"--[{1&!}/]:a[3/.zip"048642"{15&a=}%3/]{{2base""+}%}%" "*70&.{~"win""lose"if}"cat"if
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X08pwr8iX0lXN7raUE2xVj/WKjHaWF@vKrNAycDEwszESKna0FQt0bZW1Vg/trraKCmxOFVJSbtWtVZVSUFJy9xATa@6Tqk8M09JKScfKJWZVquUnFgCpP//r6kAwvwaLjBZAaTzwTQA "GolfScript – Try It Online")
Of course, the input format converted is not particularly well optimized and the combined program could easily be golfed further. However, rather than attempting to re-golf a six-year-old solution, I prefer to just keep it as close to its originally submitted form as current rules permit.
Ps. Here's a reverse converter, just to demonstrate that the redundant input format for the 27-byte version indeed does unambiguously represent the board:
```
.56,48>-- 3<{2base-3>{"ox"=}%n}%"|".@@*+);
```
[Answer]
# CJam, ~~39 38~~ 36 characters
```
"ᔔꉚ굌궽渒䗠脯뗠㰍㔚귇籾〳㎪䬔쪳儏⃒ꈯ琉"2G#b129b:c~
```
This is a base converted code for
```
q3/_z__Wf%s4%\s4%]`:Q3'o*#"win"{Q'x3*#"lose""cat"?}?
```
which is 52 characters long.
The input is simply the string representation of the board starting from top left, going row by row. For example:
```
oxooxooox
```
which results in a `win` output. Or
```
oxooxoxox
```
which results in a `cat` output, etc.
The code simply does the following three things:
* `q3/_` - Split the string into parts of 3, i.e. per row
* `_z` - Copy the per row array and transpose into per column array.
* `__Wf%s4%` - Reverse each row and get the left to right diagonal. This is the secondary diagonal of the board.
* `\s4%` - Get the main diagonal of the board
* `]`` - Wrap everything in array and stringify the array.
Now we have all possible groups of 3 from the board. We simply check for existence of "ooo" and "xxx" to determine the result.
[Try it online here](http://cjam.aditsu.net/)
[Answer]
# Haskell, 169
```
main=interact$(\x->last$"cat":[b|(a,b)<-[("ooo","lose"),("xxx","win")],any(==a)x]).(\x->x++(foldr(zipWith(:))(repeat[])x)++map(zipWith(!!)x)[[0..],[2,1,0]]).take 3.lines
```
Input format: "X" is represented only by `x`, "O" only by `o`. Within each row, characters are simultaneous without spaces, etc. Rows are separated by new lines.
Generates all possible rows/columns/diagonals, then filters `[("ooo","lose"),("xxx","win")]` by their existence on the board, then selects the second word in the tuple, so we know which players won. We prepend `"cat"` so that we can take the last element of the list as our winner. If both players won, `"win"` will be last (list comprehensions maintain order). Since `"cat"` is always first, if a winner exists, it will be chosen, but otherwise a last element still exists as prepending `"cat"` guarantees nonemptyness.
EDIT: Shaved 3 characters by changing last list comprehension to `map`.
[Answer]
# Bash, ~~107~~ 103
Generates and runs a sed script.
I/O format: `oxo-oox-xoo` outputs `lose` (use a `-` to separate rows). Input on stdin.
Requires GNU sed for the `c` command.
I've interpreted rule 5 as "if both win and lose are possible, choose win".
## Main Code
This is the actual answer.
Nothing interesting really. It defines `$b` as `/cwin` to save characters, then defines the win condition part of the script, then uses `sed y/x/o/\;s$b/close/` to convert `x` to `o` and `cwin` to `close` (thereby generating the lose conditions). It then sends the two things and `ccat` (which will output `cat` if no win/lose condition is matched) to sed.
```
b=/cwin
v="/xxx$b
/x...x...x$b
/x..-.x.-..x$b
/x-.x.-x$b"
sed "$v
`sed y/x/o/\;s$b/close/<<<"$v"`
ccat"
```
## Generated Code
This is the sed script generated and run by the Bash script.
In the regexes, `.` matches any character and after them `cTEXT` prints TEXT and exits if the regex is matched.
This can run as a standalone sed script. It's 125 characters long, you can count it as another solution.
```
/xxx/cwin
/x...x...x/cwin
/x..-.x.-..x/cwin
/x-.x.-x/cwin
/ooo/close
/o...o...o/close
/o..-.o.-..o/close
/o-.o.-o/close
ccat
```
[Answer]
## Dart - 119
(See [dartlang.org](http://dartlang.org/)).
Original version using RegExp: 151 chars.
```
main(b,{w:"cat",i,p,z}){
for(p in["olose","xwin"])
for(i in[0,2,3,4])
if(b[0].contains(new RegExp('${z=p[0]}(${'.'*i}$z){2}')))
w=p.substring(1);
print(w);
}
```
Input on the command line is 11 characters, e.g., "xxx|ooo|xxx". Any non-xo character can be used as delimiter.
Leading whitespace and newlines should be omitted before counting characters, but I cut away the internal whitespace where possible.
I wish there was a smaller way to make the substring.
Recusive bit-base version: 119 chars.
Input must be a 9-bit number with 1s representing 'x' and 0s representing 'o'.
```
main(n){
n=int.parse(n[0]);
z(b,r)=>b>0?b&n==b&511?"win":z(b>>9,n&b==0?"lose":r):r;
print(z(0x9224893c01c01e2254,"cat"));
}
```
[Answer]
# J - 56 (26?) char
Input is given a 3x3 matrix of nine characters, because J can support that as a datatype, LOL.
```
(win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.)
```
Examples:
```
NB. 4 equivalent ways to input the example board
(3 3 $ 'xxoxoxoox') ; (_3 ]\ 'xxoxoxoox') ; ('xxo','xox',:'oox') ; (];._1 '|xxo|xox|oox')
+---+---+---+---+
|xxo|xxo|xxo|xxo|
|xox|xox|xox|xox|
|oox|oox|oox|oox|
+---+---+---+---+
(win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.) 3 3 $ 'xxoxoxoox'
lose
wlc =: (win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.)
wlc (3 3 $ 'xoxoxooxo')
cat
wlc (3 3 $ 'xxxoooxxx')
win
```
If we are allowed the Golfscriptish encoding of octal digits redundantly representing the state of each row, column, and diagonal, then it's just 26 characters:
```
win`lose`cat{::~7 0<./@i.] 6 5 1 6 4 3 5 0
lose
f=:win`lose`cat{::~7 0<./@i.]
f 7 0 7 5 5 5 5 5
win
```
[Answer]
# T-SQL (2012),110
`select max(iif(@&m=0,'lose',iif(@&m=m,'win','cat')))from(VALUES(292),(146),(73),(448),(56),(7),(273),(84))z(m)`
Input is a hex number. This is pretty much a translation of the ruby solution into T-SQL pretty nice and neat.
[Answer]
# Java 7, 260 bytes
```
String c(int[]s){int a[]=new int[8],x=0,y;for(;x<3;x++){for(y=0;y<3;a[x]+=s[x*3+y++]);for(y=0;y<3;a[x+3]+=s[y++%3]);}for(x=0;x<9;y=s[x],a[6]+=x%4<1?y:0;a[7]+=x%2<1&x>0&x++<8?y:0);x=0;for(int i:a)if(i>2)return"win";for(int i:a)if(i<1)return"loose";return"cat";}
```
**Ungolfed & test cases:**
[Try it here.](https://ideone.com/ARfs4J)
```
class M{
static String c(int[] s){
int a[] = new int[8],
x = 0,
y;
for(; x < 3; x++){
for(y = 0; y < 3; a[x] += s[x * 3 + y++]);
for (y = 0; y < 3; a[x + 3] += s[y++ % 3]);
}
for(x = 0; x < 9; y = s[x],
a[6] += x % 4 < 1
? y
: 0,
a[7] += x % 2 < 1 & x > 0 & x++ < 8
? y
: 0);
x = 0;
for(int i : a){
if(i > 2){
return "win";
}
}
for(int i : a){
if(i < 1){
return "loose";
}
}
return "cat";
}
public static void main(String[] a){
/* xxo
xox
oox */
System.out.println(c(new int[]{ 1, 1, 0, 1, 0, 1, 0, 0, 1 }));
/* xxx
ooo
xxx */
System.out.println(c(new int[]{ 1, 1, 1, 0, 0, 0, 1, 1, 1 }));
/* xxo
oox
xox */
System.out.println(c(new int[]{ 1, 1, 0, 0, 0, 1, 1, 0, 1 }));
}
}
```
**Output:**
```
loose
win
cat
```
[Answer]
# Bash: 208 chars
```
y(){ tr '01' '10'<<<$@;}
f(){ x=$[($1&$2&$3)|($1&$5&$9)|($1&$4&$7)|($2&$5&$8)|($3&$5&$7)|($3&$6&$9)|($4&$5&$6)|($7&$8&$9)]; }
f $@;w=$x
f $(y $@)
([ $x -eq 1 ]&&echo lose)||([ $w -eq 1 ]&&echo win)||echo cat
```
To execute `bash tictactoe.sh 0 1 0 1 0 1 1 0 1`
Inspired by [this answer](https://codegolf.stackexchange.com/a/32395/23764).
[Answer]
# Python 2, 99 bytes
Similar to [the Ruby answer](https://codegolf.stackexchange.com/a/32401/4999):
```
def t(b):print['win'if w&b==w else'lose'if w&~b==w else'cat'for w in 448,56,7,292,146,73,273,84][0]
```
The input is the binary format described in the question: `1` for X, `0` for O, left-to-right, top-to-bottom. For example, `0b101001110` represents
```
XOX
OOX
XXO
```
which leads to output: `cat`
[Answer]
# C, 164 bytes
It's midnight here and **I haven't done any testing**, but I'll post the concept anyway. I'll get back to it tomorrow.
User inputs two octal numbers (I wanted to use binary but as far as I know C only supports octal):
`a` represents the centre square, 1 for an X, 0 for an O
`b` is a nine-digit number representing the perimeter squares, circling round the board starting in one corner and finishing in the same corner (with repeat of that corner only), 1 for an X, 0 for an O.
**There are two possible ways to win:**
1. centre square is X (`a`=1) and two opposite squares are also X (`b&b*4096` is nonzero)
2. three adjacent perimeter squares are X (`b/8 & b & b*8` is nonzero.) This is only a valid win if the middle square is an edge square, not a corner square, therefore it is necessary to apply the mask `m` also, to avoid the corner square cases.
**Losing is detected using the variable c, which is the inverse of b.**
```
int a,b,c,m=010101010;
main(){
scanf("%o%o",a,b);c=b^0111111111;
printf("%s",(a&&b&b*4096)|(b/8&b&b*8&m)?"win":((!a&&c&c*4096)|(c/8&c&c*8)?"lose":"cat"));
}
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~120~~ ~~116~~ ~~118~~ ~~112~~ ~~106~~ 102 bytes
The more compact pattern inspired by [Ventero](https://codegolf.stackexchange.com/a/32502/80745)
Fixed to follow the rule 6.
```
@(switch -r($args){($x='^(...)*111|^..1.1.1|1..(1|.1.)..1'){'win'}($x-replace1,0){'lose'}.{'cat'}})[0]
```
[Try it online!](https://tio.run/##RZDRTsMgFIbveYqTiAKmJeVmd0safQCNu1w20zF0M2grtOmSlmevHFo3uCHf//OdQFP3xvmTsXaiH7CGYSq578@tPkHuOK3cpxcDp5c123MppXhUSo17KRXuUUnJ1RiPIhImBtaff1iI9dyZxlbaqKyI1NbesCAHpquWhSC2xW4KhJSckIyzolC4VcEySAKBVCUYM6RJkHBCmCFG3VKOGPlVAXfgOmtgRYiAEe5hIBAXPdSVO2ZAzaUxujXH@GT6PkfO@M62ETzEn5iLKdi@bp4739bfL4eveGdXzipcm05r49GxXM7N7819rb39m5faNXjCIchv0wIJ0x8 "PowerShell – Try It Online")
[Answer]
## J - 97 bytes
Well, the simplest approach available. The input is taken as `111222333`, where the numbers represent rows. Read left-to-right. Player is `x` and enemy is `o`. Empty squares can be anything except `x` or `o`.
```
f=:(cat`lose>@{~'ooo'&c)`('win'"_)@.('xxx'&c=:+./@(r,(r|:),((r=:-:"1)(0 4 8&{,:2 4 6&{)@,))3 3&$)
```
Examples: (NB. is a comment)
```
f 'xoxxoxxox' NB. Victory from first and last column.
win
f 'oxxxooxxx' NB. Victory from last row.
win
f 'ooxxoxxxo' NB. The example case, lost to a diagonal.
lose
f 'xxooxxxoo' NB. Nobody won.
cat
f 'xoo xx ox' NB. Victory from diagonal.
win
```
### Ungolfed code an explanation
```
row =: -:"1 Checks if victory can be achieved from any row.
col =: -:"1 |: Checks if victory can be achieved from any column.
diag =: -:"1 (0 4 8&{ ,: 2 4 6&{)@, Checks if victory can be achieved from diagonals.
check =: +./@(row,col,diag) 3 3&$ Checks all of the above and OR's them.
f =: (cat`lose >@{~ 'ooo'&check)`('win'"_)@.('xxx'&check)
Check if you have won ........................@.('xxx'&check)
If yes, return 'win' .............. ('win'"_)
If not (cat`lose >@{~ 'ooo'&check)
Check if enemy won ................... 'ooo'&check
If yes, return 'lose' ---`lose >@{~
If not, return 'cat' cat`---- >@{~
```
[Answer]
## J : 83
```
(;:'lose cat win'){::~>:*(-&(+/@:(*./"1)@;@(;((<0 1)&|:&.>@(;|.)(,<)|:)))-.)3 3$'x'=
```
Usage: just append a string of x's and o's and watch the magic work. eg. 'xxxoooxxx'.
The inner verb `(+/@:(*./"1)@;@(;((<0 1)&|:&.>@(;|.)(,<)|:)))` basically boxes together the original binary matrix, with the transpose boxed together with the 2 diagonals.
These results are razed together ; row sums are taken to determine wins, and then summed. further I'll call this verb `Inner`.
For finding the winner, the difference of the scores between the normal and inversed binary matrices is taken by the hook `(-&Inner -.)`.
The rest of the code simply makes the outputs, and selects the right one.
[Answer]
## JavaScript, ~~133~~, 114 characters
```
r = '/(1){3}|(1.{3}){2}1|(1.{4}){2}1|(1\|.1.\|1)/';alert(i.match(r)?'WIN':i.match(r.replace(/1/g,0))?'LOSS':'CAT')
```
The input `i` is a simple string with delimiters for the rows, i.e. `100|001|100`
Edit: updated my method to replace the 1s in the regex with zeroes to check for the loss case.
[Answer]
# APL(NARS), 69 chars, 138 bytes
```
{w←3 3⍴⍵⋄x←(+/1 1⍉⊖w),(+/1 1⍉w),(+⌿w),+/w⋄3∊x:'win'⋄0∊x:'lose'⋄'cat'}
```
The input should be one 3x3 matrix or one linear array of 9 element that can be only 1 (for X) and 0 (for O), the result will be "cat" if nobody wins, "lose" if O wins, "win" if X wins. There is no check for one invalid board or input is one array has less than 9 element or more or check each element <2.
As a comment: it would convert the input in a 3x3 matrix, and build one array named "x" where elements are the sum each row column and diagonal.
Some test see example showed from others:
```
f←{w←3 3⍴⍵⋄x←(+/1 1⍉⊖w),(+/1 1⍉w),(+⌿w),+/w⋄3∊x:'win'⋄0∊x:'lose'⋄'cat'}
f 1 2 3
win
f 0 0 0
lose
f 1 0 1 1 0 1 1 0 1
win
f 0 1 1 1 0 0 1 1 1
win
f 0 0 1 1 0 1 1 1 0
lose
f 1 1 0 0 1 1 1 0 0
cat
f 1 1 0 0 1 0 0 0 1
win
f 1 1 0 1 0 1 0 0 1
lose
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 27 bytes
```
ŒD,ŒdḢ€;;ZEƇFṀị“ẏż“¡ṇ⁽“Zƙċ»
```
[Try it online!](https://tio.run/##y0rNyan8///oJBedo5NSHu5Y9KhpjbV1lOuxdreHOxse7u5@1DDn4a7@o3uA9KGFD3e2P2rcC2RGHZt5pPvQ7v///0dHG@kY6RjG6gBpQx0jIG0IpmMB "Jelly – Try It Online")
Input is a list of lists of ints: 0 = nothing, 1 = circle, 2 = cross.
## Explanation
```
ŒD,ŒdḢ€;;ZEƇFṀị“ẏż“¡ṇ⁽“Zƙċ» Main monadic link
ŒD Diagonals
, Pair with
Œd Antidiagonals
Ḣ€ Head (first item) of each
[the main diagonal and antidiagonal]
; Join with the input
; Join with the input
Z zipped (transposed)
[the diagonals, rows and columns]
Ƈ Filter by
E All elements equal?
F Flatten
Ṁ Maximum
ị Index into (1-indexed)
“ẏż“¡ṇ⁽“Zƙċ» ["lose", "win", "cat"]
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 174 bytes
```
param($a,$b,$c,$d,$e,$f,$g,$h,$i)@("$a$b$c","$a$d$g","$a$e$i","$b$e$h","$c$e$g","$c$f$i","$d$e$f","$g$h$i")|%{if($_-eq'XXX'){'win';exit}elseif($_-eq'OOO'){'lose';exit}};'cat'
```
[Try it online!](https://tio.run/##RclbCoMwEIXhvcgpUZiuwJfuIK95KzFOLpBWq4IF69rTpJaWYeDj/OOw8jR7jjGlUU/6VkMTOoIh9AQmWIIjeEJoLnUFjQ6mooIe7gAjFHQZvsBkuAP2SH1ebIGDz0vzOm3B1rie@SGUUqLZxBruouVnWHaOM/@qlLLUOMz8zXsrjF5ESkl@Tv3/DQ "PowerShell – Try It Online")
Trivial solution.
Takes 9 parameters for each key in board.
] |
[Question]
[
Given strings X and Y, determine whether X is a [subsequence](http://en.wikipedia.org/w/index.php?title=Subsequence&oldid=594253998) of Y. The empty string is regarded as a subsequence of every string. (E.g., `''` and `'anna'` are subsequences of `'banana'`.)
### Input
* X, a possibly-empty case-sensitive alphanumeric string
* Y, a possibly-empty case-sensitive alphanumeric string
### Output
* True or False (or equivalents), correctly indicating whether X is a subsequence of Y.
### I/O examples
```
X Y output
'' 'z00' True
'z00' 'z00' True
'z00' '00z0' False
'aa' 'anna' True
'anna' 'banana' True
'Anna' 'banana' False
```
### Criteria
* The shortest program wins, as determined by the number of bytes of source code.
### Example programs
* Several programs that could be adapted are in this [related posting](https://stackoverflow.com/q/6877249/1033647).
[Answer]
# [Perl 5](https://www.perl.org/), 17 bytes (+1?), full program
```
s//.*/g;$_=<>=~$_
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX19PSz/dWiXe1sbOtk4l/v//xLy8RK6kxDwgLOb6l19QkpmfV/xftwAA "Perl 5 – Try It Online")
Invoke with the `p` flag to the perl interpreter, as in `perl -pe 's//.*/g;$_=<>=~$_'`. Per [the established scoring rules when this challenge was originally posted](https://codegolf.meta.stackexchange.com/questions/273/on-interactive-answers-and-other-special-conditions), this flag costs one extra byte. Under [more recent rules](https://codegolf.meta.stackexchange.com/questions/14337/command-line-flags-on-front-ends), AFAICT, it may be free.
Either way, the input strings should be supplied on separate newline-terminated lines on stdin. Output (to stdout) will be `1` if the first input string is a substring of the second, or nothing at all if it's not.
Note that *both* input lines must have a newline at the end, or the program won't work correctly. Alternatively, you can add the `l` command line flag to the invocation to make perl strip the newlines; depending on the scoring rules in effect, this may or may not cost one extra byte. Note that using this flag will also append a newline to the output.
## Original version (snippet, 18 bytes / chars)
```
$x=~s//.*/g,$y=~$x
```
Input is given in the variables `$x` and `$y`, result is the value of the expression (in scalar context). Note that `$x` is modified in the process.
(Yes, I know using `$_` instead of `$x` would let me save four chars, but doing that in a snippet that feels a bit too cheesy for me.)
### How does it work?
The first part, `$x=~s//.*/g`, inserts the string `.*` between each character in `$x`. The second part, `$y=~$x`, treats `$x` as a regexp and matches `$y` against it. In Perl regexps, `.*` matches zero or more arbitrary characters, while all alphanumeric characters conveniently match themselves.
[Answer]
### Ruby, 32 characters
```
s=->x,y{y=~/#{[*x.chars]*".*"}/}
```
This solution returns `nil` if `x` isn't a subsequence of `y` and a number otherwise (i.e. ruby equivalents to `false` and `true`). Examples:
```
p s['','z00'] # => 0 (i.e. true)
p s['z00','z00'] # => 0 (i.e. true)
p s['z00','00z0'] # => nil (i.e. false)
p s['anna','banana'] # => 1 (i.e. true)
p s['Anna','banana'] # => nil (i.e. false)
```
[Answer]
## Haskell, ~~51~~ 37
```
h@(f:l)%(g:m)=f==g&&l%m||h%m;x%y=x<=y
```
Thanks to Hammar for the substantial improvement. It's now an infix function, but there seems to be no reason why it shouldn't.
Demonstration:
```
GHCi> :{
GHCi| zipWith (%) ["" , "z00", "z00" , "anna" , "Anna"]
GHCi| ["z00", "z00", "00z0", "banana", "banana"]
GHCi| :}
[True,True,False,True,False]
```
[Answer]
# [Python](https://www.python.org), 45 bytes
```
lambda a,b:{1,l:=iter(b)}>{c in l for c in a}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=XY3BCoMwDIbvPkVurUOh3obgYO_hJd1aLHSpuLqh4pPsIoztnXybWd3JHJL_-0jI61t3vnI0vXVRflqv0-OcWrzJKwImMh-yxOaF8arhMh5PwwUMgQXtGlgjjv8jeFbGKsjyujHkueYH9UDLDdWt5_FS2940V4wlwHohWLT2PQjRB0IMgEQYIIwFJRKu4rwXKO_Otl7ZLmhynkXbwx8)
Builds on [@qwatry's method](https://codegolf.stackexchange.com/a/217976) used in [@xnor's answer](https://codegolf.stackexchange.com/a/180287): `iter` consumes elements as they are searched for, so `c in l` "uses up" the character if it is found.
Some trickery lets us combine the `all` and the iterator assignment:
* `{c in l for c in a}` is a set comprehension which effectively deduplicates its contents, so it's always one of `{}`, `{False}`, `{True}`, or `{False, True}`
* `1` and `0` are equivalent to `True` and `False`
* The `>` operator tests if `{True, iter(b)}` is a strict superset of the result, which is true only if that result is `{}` or `{True}`, i.e. all the `c in l` expressions were true
* By including `l:=iter(b)` in the set, we can sequence the evaluation order correctly with minimal parentheses by reusing the set's `{}` grouping
* It also lets us use `>` instead of `>=` because the iterator will never be present in the boolean set
* Otherwise, `>=` would be necessary because `{True}` is not a strict superset of `{True}`
[Answer]
## Python (48 chars)
```
import re;s=lambda x,y:re.search('.*'.join(x),y)
```
Same approach as Howard's Ruby answer. Too bad about Python's need to import the regex package and its "verbose" `lambda`. :-)
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 42 bytes
```
lambda a,b:''in[a:=a[a[:1]==c:]for c in b]
```
[Try it online!](https://tio.run/##XcqxDoMgFAXQWb@CDUgcMF0aEoZ@B2W4WI0k9kkItqk/T8XR5d2ce1/85Xml2z2mMplnWfD2LzB0XnMeyEIbWFjdO2MG7aY1sYEFYt6V7xyWkfW6bY5vM36wiEBxy0LKtokpUBaTOCYpC@cd47tSvD3vFUrtVUAFiFBR46AH4Swel@IP "Python 3.8 (pre-release) – Try It Online")
**[Python 3.8 (pre-release)](https://docs.python.org/3.8/), 48 bytes**
```
lambda a,b,j=0:all((j:=1+b.find(c,j))for c in a)
```
[Try it online!](https://tio.run/##XctBCsMgEAXQdTyFO2eoFEM3JeCi9@hmTCJR7ERC2tJc3sYss5nP@5/Jv3Wa@XbPS/H2WRK93ECStNPRmo5SAoidbS/u6gMP0OuI6OdF9jKwJCzfKaRRtp1o9h87fihB4PxeAVE0eQm8god9QixKaak2Y5Q47hnGbFVEFcRMFTV2OmI6isep@AM "Python 3.8 (pre-release) – Try It Online")
In Python 3.10+, we don't need parens around the walrus expression for [46 bytes](https://ato.pxeger.com/run?1=XYxBDoIwEEXXcIru2molZWdIuuAMbt1MgYYmdSCkaOQqbkiM3onb2CIb3czP-z9vHu_-7tsO56dR59fozeG4ZA4uugYCQgurZAHOMVsonRmLNauE5fvcdAOpiEUCfLN2t9a6huRFmgRRNVcIFvajZ5ynST9Y9MywMPHNmJcTpYLQSUqarvcfpJwiAUQARIgQI6AGhLUof4vv7w8).
**[Python 2](https://docs.python.org/2/), 48 bytes**
```
lambda a,b:re.search('.*'.join(a),b)>0
import re
```
[Try it online!](https://tio.run/##XctBCsMgEIXhdTyFu9EiYrsMpNB7dDO2Bi3JKNZSmstbzTKbeXw/TPoVH@lS5@leF1ztEzkqO2an3w7zwwvQJ9CvGEigVFZeDQtrirnw7OrXh8Xx88iG9jMFSp8iJBtSDlTELFqUsgIoDpsxwPZ7hDFbF2IHEmFHn0aLhHu4HcIf "Python 2 – Try It Online")
Copied from [this answer of Lynn](https://codegolf.stackexchange.com/a/180248/20260). The `>0` can be omitted if just truthy/falsey output is OK.
**[Python 2](https://docs.python.org/2/), 49 bytes**
```
def f(a,b):l=iter(b);print all(c in l for c in a)
```
[Try it online!](https://tio.run/##XcwxDsMgDAXQOZzCGyBloB1TZehRTAuKJctBiKpqLk8CmdLF3@9LdvqVZZV7re8QIRocvZ14phKy8faRMkkBZDYvIAGGuGboK9r6XYgD3CY1HFczSfoUY9VwPqlaj6A357Tq8x/ObU2IDSiCDS0OehTsxfNa7A "Python 2 – Try It Online")
A dazzling new method [introduced to me by qwatry](https://codegolf.stackexchange.com/a/217976/20260). The idea is that turning `b` into the iterator `l` will consume values whenever they are read. So, checking `c in l` will consume values left to right until it finds one that equals `c` or it reaches the end.
**[Python 2](https://docs.python.org/2/), 50 bytes**
```
f=lambda a,b:b and f(a[a[:1]==b[0]:],b[1:])or''==a
```
[Try it online!](https://tio.run/##XcuxCoMwGATgWZ8i228gQ@wYyNDnCBnux4qC/Q2SUurLp4mjyx3fwaVfXnZ5lDL7DW@eoGDYsYJMah4QENwYvedgo4uGw@ii3g8i71G@y7q91Oj6rn78KumTB9136VglD/VsWOtCZBSd1lJ/5R3Wnk1AA0TQ0KqSIbiG5234Aw "Python 2 – Try It Online")
**[Python 2](https://docs.python.org/2/), 50 bytes**
```
lambda a,b:reduce(lambda s,c:s[c==s[:1]:],b,a)==''
```
[Try it online!](https://tio.run/##XcuxDoMgEMbxWZ6CDUgYsCMJQ5/DOhyIkcReiWBMfXkKppPLffn9k4vfvHzwUWbzKiu87QQUpNWbn3bn@b8k6XQanDFp0P2oR2klCGMYK8cSVk97Tbr6ZQLGPXNBurgFzHzmNQpRGJOUnUoxct07lDqbABoAERraVFpAuMLzFn4 "Python 2 – Try It Online")
[Answer]
## Python, 59 characters
```
def s(x,y):
for c in y:
if x:x=x[c==x[0]:]
return x==""
```
I figured my answer would be better expressed in Python.
Edit: Added r.e.s.'s suggestions.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 2 bytes
```
⊆ᵈ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFSuVv2obcOjpuZHHcuVSopKU5VqQKy0xJziVKXaciU9BaWHuzprH26d8P9RV9vDrR3//0dHKynpKFUZGCjF6kSDaXSegUEVhJuYCOQl5uUlQnggho5SUmJeIlTEEVUkFgA "Brachylog – Try It Online")
As with [this answer,](https://codegolf.stackexchange.com/a/180657/85334) `⊆` is a built-in predicate that declares a relationship between the input and output variables, and `ᵈ` is a meta-predicate that modifies it to declare that same relationship between the first and second elements of the input variable instead (and unify the output variable with the second element but as this is a decision problem that doesn't end up mattering here). `X⊆Y` is an assertion that X is a subsequence of Y, therefore so is `[X,Y]⊆ᵈ`.
This predicate (which of course outputs through success or failure which prints `true.` or `false.` when it's run as a program) takes input as a list of two strings. If input is a bit more flexible...
# [Brachylog](https://github.com/JCumin/Brachylog), 1 byte
```
⊆
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFSuVv2obcOjpuaHWzsedSxXKikqTVWqAbHSEnOKU5Vqy5X0FJQe7uqsfbh1wv9HXW3//0dHKynpKFUZGCjF6kSDaXSegUEVhJuYCOQl5uUlQnggho5SUmJeIlTEEVUkFgA "Brachylog – Try It Online")
Takes string X as the input variable and string Y as the output variable. Outputs through success or failure, as before. [If run as a full program,](https://tio.run/##SypKTM6ozMlPN/r//1FX2///Sol5eYlK/5WSEvOAUAkA) X is supplied as the input and Y is supplied as the first command line argument.
[Answer]
## GolfScript (22 chars)
```
X[0]+Y{1$(@={\}*;}/0=!
```
Assumes that input is taken as two predefined variables `X` and `Y`, although that is rather unusual in GolfScript. Leaves `1` for true or `0` for false on the stack.
[Answer]
## C (52 chars)
```
s(char*x,char*y){return!*x||*y&&s(*x-*y?x:x+1,y+1);}
```
[Test cases](http://ideone.com/kMU8Y)
[Answer]
# Burlesque (6 chars)
6 chars in Burlesque:
`R@\/~[`
(assuming x and y are on the stack. See [here](http://eso.mroman.ch/cgi/burlesque.cgi?q=%22anna%22%22banana%22R%40%5C%2F~%5B) in action.)
[Answer]
# C, 23:
```
while(*y)*x-*y++?0:x++;
```
result in \*x
<http://ideone.com/BpITZ>
[Answer]
## PHP, 90 characters
```
<?function s($x,$y){while($a<strlen($y))if($y[$a++]==$x[0])$x=substr($x,1);return $x=="";}
```
[Answer]
### Scala 106:
```
def m(a:String,b:String):Boolean=(a.size==0)||((b.size!=0)&&((a(0)==b(0)&&m(a.tail,b.tail))||m(a,b.tail)))
```
[Answer]
## CoffeeScript ~~112~~ ~~100~~ ~~95~~ 89
My first attempt at code golf... hope I don't shame my family!
```
z=(x,y)->a=x.length;return 1if!a;b=y.indexOf x[0];return 0if!++b;z x[1..a],y[b..y.length]
```
**Edit**: turns out Coffeescript is more forgiving than I thought with whitespace.
**Thanks to r.e.s. and Peter Taylor for some tips for making it a bit sleeker**
[Answer]
# C #, ~~70~~ ~~113~~ ~~107~~ 90 characters
```
static bool S(string x,string y){return y.Any(c=>x==""||(x=x.Remove(0,c==x[0]?1:0))=="");}
```
[Answer]
# Mathematica 19 17 27
`LongestCommonSequence` returns the longest non-contiguous subsequence of two strings. (Not to be confused with `LongestCommonSubsequence`, which returns the longest contiguous subsequence.
The following checks whether the longest contiguous subsequence is the first of the two strings. (So you must enter the shorter string followed by the larger string.)
```
LongestCommonSequence@##==#&
```
**Examples**
```
LongestCommonSequence@## == # &["", "z00"]
LongestCommonSequence@## == # &["z00", "z00"]
LongestCommonSequence@## == # &["anna", "banana"]
LongestCommonSequence@## == # &["Anna", "banana"]
```
True True True False
The critical test is the third one, because "anna" is contained non contiguously in "banana".
[Answer]
# PHP, 41 Bytes
prints 1 for true and nothing for false
```
<?=!levenshtein($argv[1],$argv[2],0,1,1);
```
If only insertions from word 1 to word 2 done the count is zero for true cases
[levenshtein](http://php.net/manual/en/function.levenshtein.php)
[Try it online!](https://tio.run/nexus/php#ZczBCoJAEAbgu09hW7AKE@x21ZIuPUE328MkUyvIKm55MHp2U9fEaE7D//H/cVLpyruVNWGmgzRlWwacA2@F4Mpfn@sneeDSIZrB729A/1eFaL98wsLOXcQe0RiccLk7xsCvaHDypR7/1A0rtBus7034Sg5dnOxXBTVkrH5QboJRUqnAPTsFAiTIMOoo0yW7GBa9uw8 "PHP – TIO Nexus")
## PHP, 57 Bytes
prints 1 for true and 0 for false
Creates a Regex
```
<?=preg_match(_.chunk_split($argv[1],1,".*")._,$argv[2]);
```
[Try it online!](https://tio.run/nexus/php#Zc9NDoIwEAXgPacg1aRgKiluQYkbT@AOm2YkhRqxNAVcYDw78ifBOMv3zbxkwkhLbaWFEZBIJ47RFhGMCW4oxcxenU0tLDKmfTSD3U2P9q9S2nz5BHk53wJ0CErBhMveISb4CgomX@rxT8diBuUaTPZ0X9GhDaO9NiLjD6i6L7iXyFrdeanzW@UMW7HPiE@Qt0Gux8kY7ZgbtCKRBbooFLzbDw "PHP – TIO Nexus")
[Answer]
# [Haskell](https://www.haskell.org/), 36 bytes
```
(a:b)%(c:d)=([a|a/=c]++b)%d
s%t=s<=t
```
[Try it online!](https://tio.run/##TYq9DsIgFIV3n@LmRhJINTI33sGncGgYbqlaIhIiTMRnF2nj0JzhO38zp@fN@1ol96MS0vaTIjnwh09kTde1btolkSmdKdcXuwAE8e1Chj0UF68uzyCFggERAA6ARWv8Y4kcAuM6XBZn2nHzaNC6rBw5NG2cqV979/xI9Whj/AE "Haskell – Try It Online")
---
**37 bytes**
```
(.map concat.mapM(\c->["",[c]])).elem
```
[Try it online!](https://tio.run/##TYtBCsMgEEX3PcUgLRhIghew0AN03UXiYiraSHUijSsPX6uhizCL9z7/z4Lb23hfrJwLHwNG0CtpTE3vfNbDdWKsn7RSXTcab0Lhl07aU0BHICF@HCU4Q3bx4dICtYT6AAA9sCwE@6NFJEK2F7dmqg4Piwoh8s4nUr2DqfLV1uNrK4OO8Qc "Haskell – Try It Online")
I think `mapM` postdates this challenge. If we can assume the characters are printable, we can do
**36 bytes**
```
(.map(filter(>' ')).mapM(:" ")).elem
```
[Try it online!](https://tio.run/##TYrBCsIwEETvfsWwKE1AJWchQj/AswftYS2JDSYhtDn1441p8VD28N7szMDTx3hfrH4WcQ6chHU@m1FcGzRSLp@buBCouvEmFHGQ2u4CuwiNNLqYscfs0t3lAbXEgwjAETQrRX8skWNkWot2sa4ON4sKpeaVL471NtaVb289v6dy6lP6AQ "Haskell – Try It Online")
---
**37 bytes**
```
(null.).foldr(?)
c?(h:t)|c==h=t
c?s=s
```
[Try it online!](https://tio.run/##TYqxCgIxEER7v2IJFgnokVpYDr/CQq9YozHBNRcusQl@uzF3WBxTvHnMOErPO3O1eKkyvJk71dmRb5Ps1cb00h2y@hhEh7lpwlRf5AMgxMmHDFsoPp58dmDhLAQA7EAUrcUfs1IIJJbhOLehHVePBq3LwiuFllUb6tdYpkeqexPjDw "Haskell – Try It Online")
[Answer]
## JavaScript (no regex), 45 bytes
```
y=>x=>(i=0,[...y].map(c=>c==x[i]&&i++),!x[i])
```
Should be called like
```
f(haystack)(needle)
```
[Answer]
# C - 74 71 64
This doesn't beat Peter Taylor's solution, but I think it's pretty fun (plus, this is a complete working program, not just a function)
```
main(int c,char**v){for(;*v[1]!=0;++v[1])v[2]+=*v[1]==*v[2];return*v[2];}
```
---
```
main(int c,char**v){for(;*v[1];++v[1])v[2]+=*v[1]==*v[2];return*v[2];}
```
---
```
main(c,v)char**v;{while(*v[1])v[2]+=*v[1]++==*v[2];return*v[2];}
```
And ungolfed:
```
main(int argc, char** argv){
char * input = argv[1];
char * test = argv[2];
// advance through the input string. Each time the current input
// character is equal to the current test character, increment
// the position in the test string.
for(; *input!='\0'; ++input) test += *input == *test;
// return the character that we got to in the test string.
// if it is '\0' then we got to the end of the test string which
// means that it is a subsequence, and the 0 (EXIT_SUCCESS) value is returned
// otherwise something non-zero is returned, indicating failure.
return *test;
}
```
To test it you can do something like:
```
./is_subsequence banana anna && echo "yes" || echo "nope"
# yes
./is_subsequence banana foobar && echo "yes" || echo "nope"
# nope
```
[Answer]
## Python, ~~66~~ ~~62~~ ~~59~~ 58 chars
Kind of a fun solution, definitely a neat problem.
```
def f(n,h,r=0):
for c in h:r+=n[r:r+1]==c
return r==len(n)
```
[Answer]
## Ruby ~~32~~ ~~30~~ 28
```
f=->a,b{b.match a.tr'','.*'}
```
This will return `MatchData` instance if `a` is subsequence of `b` or `nil` otherwise.
**Old version that find substring instead of subsequence**
## Ruby 15
```
f=->a,b{!!b[a]}
```
Using `String#[](str)` method that returns `str` if `str` is a substring of `self` and `!!` to return `Boolean` if returned value can be usable as boolean (and don't need to be `true` or `false`) then it can be only 13 chars:
```
f=->a,b{b[a]}
```
It will return `nil` if `a` is not a substring of `b`.
[Answer]
# SWI-Prolog, SICStus
The built-in predicate [sublist/2](http://www.swi-prolog.org/pldoc/doc_for?object=sicstus_lists%3asublist/2) of SICStus checks whether all the items in the first list also appear in the second list. This predicate is also available in SWI-Prolog via compatibility library, which can be loaded by the query `[library(dialect/sicstus/lists)].`.
Sample run:
```
25 ?- sublist("","z00").
true.
26 ?- sublist("z00","z00").
true .
27 ?- sublist("z00","00z0").
false.
28 ?- sublist("aa","anna").
true .
29 ?- sublist("anna","banana").
true .
30 ?- sublist("Anna","banana").
false.
```
The byte count can technically be 0, since all we are doing here is querying, much like how we run a program and supply input to it.
[Answer]
# [Red](http://www.red-lang.org), 82 bytes
```
func[x y][parse/case y collect[foreach c x[keep reduce['to c 'skip]]keep[to end]]]
```
[Try it online!](https://tio.run/##bckxDoMwDEDRnVNYWRibuVuv0NXy4DqOikBJlIAEXD6QpQKp438/q6tvdUidf0L1SxBcYSNMnIs@hIvCBhKnSWVGH7OyfEFgxVE1QVa3iGI/x9P6Mg6JqA08QYMjopryEGbwYAyY3VrT/aDVf7N2vyLzaRwCX60lmA8Hvvnr5vUA "Red – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
æQà
```
[Try it online](https://tio.run/##yy9OTMpM/f//8LLAwwv@/09KzANCrsS8vEQA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWXC/8PLAg8v@K/zPzpaSUlHqcrAQClWRyEazMDgGhhUQfmJiUBuYl5eIpQLYukoJSXmJcKEHFGFYgE).
Or alternatively:
```
æså
```
[Try it online](https://tio.run/##yy9OTMpM/f//8LLiw0v//09KzANCrsS8vEQA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWXC/8PLig8v/a/zPzpaSUlHqcrAQClWRyEazMDgGhhUQfmJiUBuYl5eIpQLYukoJSXmJcKEHFGFYgE).
With both programs the first input is \$Y\$ and the second input is \$X\$.
**Explanation:**
```
æ # Get the powerset of the (implicit) input-string `Y`
Q # Check for each if it's equal to the (implicit) input-String `X`
à # And check if any are truthy by taking the maximum
# (after which this result is output implicitly)
æ # Get the powerset of the (implicit) input-String `Y`
s # Swap to take the (implicit) input-String `X`
# (could also be `I` or `²` to simply take input)
å # Check if this string is in the powerset-list of strings
# (after which this result is output implicitly)
```
[Answer]
# x86-16 machine code, ~~12~~ 10 bytes
**Binary:**
```
00000000: 41ac f2ae e303 4a75 f8c3 A.....Ju..
```
**Unassembled listing:**
```
41 INC CX ; Loop counter is 1 greater than string length
SCAN_LOOP:
AC LODSB ; load next char of acronym into AL
F2 AE REPNZ SCASB ; search until char AL is found
E3 03 JCXZ DONE ; stop if end of first string reached
4A DEC DX ; decrement second string counter
75 F8 JNZ SCAN_LOOP ; stop if end of second string reached
DONE:
C3 RET ; return to caller
```
Callable function. Input: `Y` string pointer in `SI`, length in `CX`. `X` string pointer in `DI`, length in `DX`. Output is `ZF` if `Truthy`.
**Example test program:**
This test program uses additional PC DOS API I/O routines to take multi-line input from `STDIN`.
[](https://i.stack.imgur.com/KLrYN.png)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~18~~ 17 bytes
```
ＦηＦ⁼ι∧θ§θ⁰≔Φθμθ¬θ
```
[Try it online!](https://tio.run/##HYg7DoQwDAV7TuHSlkCip6IAaRvEFbzhFynrKB/Q3t4E5hXzNObgaDw71c1HwIPg9RBOdgltDb0sGIryR5b1/9yWCtCnZHfB0bq8xif/qIZAXTVHKxknnzEQdaoswtWXpUyby90 "Charcoal – Try It Online") Link is to verbose version of code. Uses Charcoal's default Boolean output of `-` for true, nothing for false. Explanation:
```
Ｆη
```
Loop over the characters of `Y`.
```
Ｆ⁼ι∧θ§θ⁰
```
See if this character is the next character of `X`.
```
≔Φθμθ
```
If so then remove that character from `X`.
```
¬θ
```
Were all the characters of `X` consumed?
[Answer]
# [Factor](https://factorcode.org/) + `math.combinatorics`, 19 bytes
```
[ all-subsets in? ]
```
[Try it online!](https://tio.run/##Zc@xCsIwGATgPU9xzW7JrKA4iYtLcRKHP6HBQJuW5newpc8eQ2ul4o33ccNZMtx08VqcL6ctauJHbppaO0@pdiYglBzQdiXzq@2cZ1AITep3QgwCKQOkhOyVkhjxSQZebII1J8MvKtUvmsEuRpSIvKfV8GtTLTV5mn1lx3@zYhTxBqqqTXjq6ZHzB9yjnd/sa2qRxzc "Factor – Try It Online")
[Answer]
# Haskell + [hgl](https://gitlab.com/WheatWizard/haskell-golfing-library), 2 bytes
```
iS
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ8FNlczcgvyiEoXC0sSczLTM1BSFgKLUnNKUVC6oRABXte7S0pI0XYtFmcEQxs3purVcXLmJmXkKtgop-VwKCgVFCioKmcEKSol5eYlKCkpJiXlAqIQsAxStMjBAEQLxMUUTQQaAzcFUa2BQharYEWKfE8Q-iPMWLIDQAA)
So this is a builtin. There are actually a couple of builtins. There's also `fiS` which is the same function but the arguments flipped, there `iSW eq` which how `iS` is defined internally. There's `fe<ss` which gets all subsequences of `y` and checks if `x` is among them. There's `ap eq<lSW` which tests if the longest common subsequence is equal to the second element.
But these are no fun. Let's have a true no builtins solution
# Regex based, 17 bytes
```
pP<rXx<ic".*"<m p
```
Also
```
pP<rXx<ic".*"<!<p
```
This works like all the other regex answers here. It adds `.*` between items and then matches a regex.
# Parser based, 15 bytes
```
pP<mF(aK h'<χ)
```
This works similarly to the regex answer. It replace every character in the string with a parser that matches anything ending in that character. It then sequences all the parsers and checks if there is any partial matches.
It's cheaper than the regex which is a little surprising.
# Reflections
The regex answer is the one with the most room for improvement.
* There should be functions that build and apply regexes all in one. It's silly to have to build and then apply the regex separately. This would save 3 bytes on the regex solution
* Hard to imagine a situation in which `<!<` is going to be useful. Here we can see it's not saving anything. Maybe this should be shortened, the docs should have some info about when it is useful.
* There should be more versions of `ic` and `is`. Some that add copies to the outside, and a versions that are mapped with pure like the regex answer.
With the above changes the regex answer could look like
```
pPX<icp".*"
```
The only other suggestion I have is that *maybe* `aK h'` should get a synonym. It's basically "ends with", which seems like a concept that might come up again.
] |
[Question]
[
**This question already has answers here**:
[Character counts in source code](/questions/50980/character-counts-in-source-code)
(9 answers)
Closed 6 years ago.
*Oh, `<PROGRAM NAME HERE>`, tell me how many character '`<CHARACTER HERE>`'/s are there in your body.*
---
I do not think it a dupe to [this](https://codegolf.stackexchange.com/questions/50980/character-counts-in-source-code). That question asks for printing a list directly but this one requires some input that will cause problem.
Your work is to write a quine-like program/function that takes an input of one character, and respond with a number telling how many times that character occurs in your program. Comments, indents, trailing spaces, line feeds all count.
The range of acceptable input **MUST** cover all characters the language you are using can accept (not as string literals or comments) and all characters with lesser index in Unicode. For exmaple, Javascript and Python 3 accept Unicode characters for variable name, then it **MUST** allow Unicode input. For some stack processing languages, there are characters like `‘Ȯß`, so part of the non-ASCII input **MUST** also be acceptable.
For example, if your program is in pure ASCII and only LF
```
foo(bar,baz)#there is a space->
do things
```
The inputs and outputs should be:
* \n -> 1
* \r -> 0
* \t -> 0
* -> 9
* `a` -> 4
* `b` -> 2
* `(` -> 1
* `)` -> 1
* \x01 through \x09 -> 0
* `＋`(U+FF0B) -> undefined behaviour (you can even destroy everything or delete the program itself furiously)
The program with least characters wins.
[Answer]
# Python, 172 chars
```
lambda a:'-mbda#l.fn()+1: \\\'i'.find(a)+1#\\\\\\\\\\\\\\((((((((())))))))))fffffffbd####lllll......nnnnnnnn+1+1+1+1+1+1+1+1+1+1+11::::::::::::: '''''''''''''''iiiiiiiiiiiiiiiii
```
Using `str.find()+1` to generate 0 for any character not in program.
Using comment for complement.
] |
[Question]
[
# Introduction
Time is confusing. Sixty seconds to a minute, sixty minutes to an hour, twenty-four hours to a day (and not to mention that pesky am/pm!).
There's no room for such silliness nowadays, so we've decided to adopt the only sensible alternative: decimal days! That is to say, each day is considered 1 whole unit, and anything shorter is written as a decimal fraction of that day. So, for example: "12:00:00" would be written as "0.5", and "01:23:45" might be written as "0.058159".
Because it will take time to get used to the new system, you are tasked with writing a program that can convert between them in both directions.
# Challenge
Write a program in the language of your choice, that given a modern time in the ISO-8601 format of "hh:mm:ss", will return the equivalent decimal fraction unit. Likewise, given a decimal fraction, the program should return the time in the modern format initially specified.
You can make the following assumptions:
* The modern time input and output can range from "00:00:00" to "24:00:00"
* The decimal time input and output can range from "0" to "1", and should be able to accept/output up to at least 5 decimal places (such as "0.12345"). More precision is acceptable
* The program should be able to know which conversion direction to perform based on input
* You cannot use time related functions/libraries
The winner will be determined by the shortest code that accomplishes the criteria. They will be selected in at least 7 decimal day units, or if/when there have been enough submissions.
# Examples
Here's a(n intentionally) poorly written piece of JavaScript code to be used as an example:
```
function decimalDay(hms) {
var x, h, m, s;
if (typeof hms === 'string' && hms.indexOf(':') > -1) {
x = hms.split(':');
return (x[0] * 3600 + x[1] * 60 + x[2] * 1) / 86400;
}
h = Math.floor(hms * 24) % 24;
m = Math.floor(hms * 1440) % 60;
s = Math.floor(hms * 86400) % 60;
return (h > 9 ? '' : '0') + h + ':' + (m > 9 ? '' : '0') + m + ':' + (s > 9 ? '' : '0') + s;
}
decimalDay('02:57:46'); // 0.12344907407407407
decimalDay('23:42:12'); // 0.9876388888888888
decimalDay(0.5); // 12:00:00
decimalDay(0.05816); // 01:23:45
```
[Answer]
# CJam, ~~58 56~~ 42 bytes
I am sure this is too long and can be golfed a lot. But here goes for starters:
```
86400q':/:d_,({60bd\/}{~*i60b{s2Ue[}%':*}?
```
[Try it online here](http://cjam.aditsu.net/#code=86400q'%3A%2F%3Ad_%2C(%7B60bd%5C%2F%7D%7B~*i60b%7Bs2Ue%5B%7D%25'%3A*%7D%3F&input=0.9998842592592593)
[Answer]
# Python 2, ~~159~~ ~~150~~ 141 + 2 = 143 Bytes
Straightforward solution, can probably be much shorter. Will work on it.
*Added two bytes to account for input needing to be enclosed in "s. Also, Sp3000 pointed out an issue with eval() interpreting octals, and showed a way to shorten formatting, use map() and remove one print.*
```
n=input();i=float;d=864e2
if':'in n:a,b,c=map(i,n.split(':'));o=a/24+b/1440+c/d
else:n=i(n);o=(':%02d'*3%(n*24,n*1440%60,n*d%60))[1:]
print o
```
[Check it out on ideone here.](http://ideone.com/WVPBAO)
[Answer]
# Javascript (*ES6*), 116 110 bytes
```
f=x=>x[0]?([h,m,s]=x.split(':'),+s+m*60+h*3600)/86400:[24,60,60].map(y=>('0'+~~(x*=y)%60).slice(-2)).join(':')
// for snippet demo:
i=prompt();
i=i==+i?+i:i; // convert decimal string to number type
alert(f(i))
```
**Commented:**
```
f=x=>
x[0] ? // if x is a string (has a defined property at '0')
([h, m, s] = x.split(':'), // split into hours, minutes, seconds
+s + m*60 + h*3600) // calculate number of seconds
/ 86400 // divide by seconds in a day
: // else
[24, 60, 60]. // array of hours, minutes, seconds
map(y=> // map each with function
('0' + // prepend with string zero
~~(x *= y) // multiply x by y and floor it
% 60 // get remainder
).slice(-2) // get last 2 digits
).join(':') // join resulting array with colons
```
[Answer]
## Python 3: 143 Bytes
```
i,k,l,m=input(),60,86400,float
if'.'in i:i=m(i)*l;m=(3*':%02d'%(i/k/k,i/k%k,i%k))[1:]
else:a,b,c=map(m,i.split(':'));m=(a*k*k+b*k+c)/l
print(m)
```
Same byte count as the python 2 solution but it seems we took different approaches to the maths.
[Answer]
# Julia, ~~152~~ ~~143~~ 142 bytes
Well, I updated my approach to be less "Julian," as they say, for the sake of golfing. For a better (though less concise) approach, see the revision history.
```
x->(t=[3600,60,1];d=86400;typeof(x)<:String?dot(int(split(x,":")),t)/d:(x*=d;o="";for i=t q,x=x÷i,x%i;o*=lpad(int(q),2,0)*":"end;o[1:end-1]))
```
This creates an unnamed function that accepts a string or a 64-bit floating point number and returns a 64-bit floating point number or string, respectively. To call it, give it a name, e.g. `f=x->...`.
Ungolfed + explanation:
```
function f(x)
# Construct a vector of the number of seconds in an hour,
# minute, and second
t = [3600, 60, 1]
# Store the number of seconds in 24 hours
d = 86400
# Does the type of x inherit from the type String?
if typeof(x) <: String
# Compute the total number of observed seconds as the
# dot product of the time split into a vector with the
# number of seconds in an hour, minute, and second
s = dot(int(split(x, ":")), t)
# Get the proportion of the day by dividing this by
# the number of seconds in 24 hours
s / d
else
# Convert x to the number of observed seconds
x *= d
# Initialize an output string
o = ""
# Loop over the number of seconds in each time unit
for i in t
# Set q to be the quotient and x to be the remainder
# from x divided by i
q, x = divrem(x, i)
# Append q to o, padded with zeroes as necessary
o *= lpad(int(q), 2, 0) * ":"
end
# o has a trailing :, so return everything up to that
o[1:end-1]
end
end
```
Examples:
```
julia> f("23:42:12")
0.9876388888888888
julia> f(0.9876388888888888)
"23:42:12"
julia> f(f("23:42:12"))
"23:42:12"
```
[Answer]
# C, 137 bytes
Full C program. Takes input on stdin and outputs on stdout.
```
main(c){float a,b;scanf("%f:%f:%d",&a,&b,&c)<3?c=a*86400,printf("%02d:%02d:%02d",c/3600,c/60%60,c%60):printf("%f",a/24+b/1440+c/86400.);}
```
Ungolfed and commented:
```
int main() {
// b is float to save a . on 1440
float a,b;
// c is int to implicitly cast floats
int c;
// If the input is hh:mm:ss it gets splitted into a, b, c
// Three arguments are filled, so ret = 3
// If the input is a float, it gets stored in a
// scanf stops at the first semicolon and only fills a, so ret = 1
int ret = scanf("%f:%f:%d", &a, &b, &c);
if(ret < 3) {
// Got a float, convert to time
// c = number of seconds from 00:00:00
c = a * 86400;
printf("%02d:%02d:%02d", c/3600, c/60 % 60, c%60);
}
else {
// a = hh, b = mm, c = ss
// In one day there are:
// 24 hours
// 1440 minutes
// 86400 seconds
printf("%f", a/24 + b/1440 + c/86400.);
}
}
```
[Answer]
# J, 85 bytes
Results:
T '12:00:00'
0.5
T 0.5
12 0 0
T '12:34:56'
0.524259
T 0.524259
12 34 56
```
T=:3 :'a=.86400 if.1=#y do.>.(24 60 60#:y*a)else.a%~+/3600 60 1*".y#~#:192 24 3 end.'
```
Total 85
[Answer]
# Javascript, ~~194~~ ~~192~~ ~~190~~ 188 bytes
```
function(z){if(isNaN(z)){x=z.split(':');return x[0]/24+x[1]/1440+x[2]/86400}h=(z*24)|0;h%=24;m=(z*1440)|0;m%=60;s=(z*86400)|0;s%=60;return""+(h>9?'':0)+h+':'+(m>9?'':0)+m+':'+(s>9?'':0)+s}
```
[Answer]
# JavaScript ES6, ~~98~~ 130 bytes
```
s=>s==+s?'246060'.replace(/../g,l=>':'+('0'+~~(s*=+l)%60).slice(-2)).slice(1):s.split`:`.reduce((a,b)=>+b+(+a)*60)*1/864e2;f(0.5);
```
[Answer]
# C, ~~156~~ 152 bytes
I thought it is going to be easy for C. But still ended up quite large. :(
```
n,m=60;d(char*s){strchr(s,58)?printf("%f",(float)(atoi(s)*m*m+atoi(s+3)*m+atoi(s+6))/m/m/24):printf("%02d:%02d:%02d",(n=atof(s)*m*m*24)/m/m,n/m%m,n%m);}
```
Test Program:
```
#include <stdio.h>
#include <stdlib.h>
int n,m=60;
d(char*s)
{
strchr(s,':') ?
printf("%f",(float)(atoi(s)*m*m+atoi(s+3)*m+atoi(s+6))/m/m/24):
printf("%02d:%02d:%02d",(n=atof(s)*m*m*24)/m/m,n/m%m,n%m);
}
int main()
{
d("01:23:45");
printf("\n");
d("02:57:46");
printf("\n");
d("23:42:12");
printf("\n");
d("12:00:00");
printf("\n");
d("0.5");
printf("\n");
d("0.05816");
printf("\n");
d("0");
printf("\n");
d("1");
printf("\n");
return 0;
}
```
Output:
```
0.058160
0.123449
0.987639
0.500000
12:00:00
01:23:45
00:00:00
24:00:00
```
[Answer]
# PHP, ~~70~~ 69 bytes
```
<?=strpos($t=$argv[1],58)?strtotime($t)/86400:date("H:i:s",$t*86400);
```
takes input from command line argument, prints to STDOUT:
If input contains a colon, convert to unix time and divide by (seconds per day),
else multply numeric value with (seconds per day) and format unix time to `hh:mm:ss`.
[Answer]
# Perl, ~~109~~ ~~108~~ 101 + 6 (`-plaF:` flag) = 107 bytes
```
$_=$#F?($F[0]*60+$F[1]+$F[2]/60)/1440:sprintf"%02d:%02d:%02d",$h=$_*24,$m=($h-int$h)*60,($m-int$m)*60
```
Using:
```
perl -plaF: -e '$_=$#F?($F[0]*60+$F[1]+$F[2]/60)/1440:sprintf"%02d:%02d:%02d",$h=$_*24,$m=($h-int$h)*60,($m-int$m)*60' <<< 01:23:45
```
[Try it on Ideone.](http://ideone.com/6pWG2B)
[Answer]
# Excel, 178 bytes
```
=IF(LEFT(A1,2)="0.",TEXT(FLOOR(A1*24,1),"00")&":"&TEXT(MOD(FLOOR(A1*1440,1),60),"00")&":"&TEXT(MOD(FLOOR(A1*86400,1),60),"00"),((LEFT(A1,2)*60+MID(A1,4,2))*60+RIGHT(A1,2))/86400)
```
] |
[Question]
[
Given a list of strings, find the **smallest square** matrix that contains each of the initial strings. The strings may appear horizontally, vertically or diagonally and forwards or backwards like in this question [Word Search Puzzle](https://codegolf.stackexchange.com/questions/37940/word-search-puzzle/37976#37976).
Words should be placed in the square, with at least one word in each direction (horizontal, vertical and diagonal). Words should appear just one time.
So, the input is just a list of words. For example: `CAT, TRAIN, CUBE, BICYCLE`. One possible solution is:
```
B N * * * * *
* I * * C A T
* A C * * * *
* R * Y * * C
* T * * C * U
* * * * * L B
* * * * * * E
```
I replaced filling letters with asterisks just for clarity. The desired output should include random filling letters.
[Answer]
# JavaScript (ES6), 595 ~~628 680~~
**Edit** Some cleanup and merge:
- function P merged inside function R
- calc x and z in the same .map
- when solution found, set x to 0 to exit outer loop
- merged definiton and call of W
**Edit2** more golfing, random fill shortened, outer loop revised ... see history for something more readable
~~Unlike the accepted answer,~~ this should work for most inputs. Just avoid single letter words. If an output is found, it's optimal and using all 3 directions.
The constraint of avoiding repeating words is very hard.
I had to look for repeating word at each step adding word to the grid, and at each random fill character.
Main subfunctions:
* P(w) true if palindrome word. A palindrom word will be found twice when checking for repeated words.
* R(s) check repeating words on grid s
* Q(s) fill the grid s with random characters - it's recursive and backtrack in case of repeating word - and can fail.
* W() recursive, try to fill a grid of given size, if possibile.
The main function use W() to find an output grid, trying from a size of the longest word in input up to the sum of the length of all words.
```
F=l=>{
for(z=Math.max(...l.map(w=>(w=w.length,x+=w,w),x=0));
++z<=x;
(W=(k,s,m,w=l[k])=>w?s.some((a,p)=>!!a&&
D.some((d,j,_,r=[...s],q=p-d)=>
[...w].every(c=>r[q+=d]==c?c:r[q]==1?r[q]=c:0)
&&R(r)&&W(k+1,r,m|1<<(j/2))
)
)
:m>12&&Q(s)&&(console.log(''+s),z=x)
)(0,[...Array(z*z-z)+99].map((c,i)=>i%z?1:'\n'))
)
D=[~z,-~z,1-z,z-1,z,-z,1,-1]
,R=u=>!l.some(w=>u.map((a,p)=>a==w[0]&&D.map(d=>n+=[...w].every(c=>u[q+=d]==c,q=p-d)),
n=~([...w]+''==[...w].reverse()))&&n>0)
,Q=(u,p=u.indexOf(1),r=[...'ABCDEFGHIJHLMNOPQRSTUVWXYZ'])=>
~p?r.some((v,c)=>(r[u[p]=r[j=0|c+Math.random()*(26-c)],j]=v,R(u)&&Q(u)))||(u[p]=1):1
//,Q=u=>u.map((c,i,u)=>u[i]=c!=1?c:' ') // uncomment to avoid random fill
}
```
**Ungolfed** and explained (incomplete, sorry guys it's a lot of work)
```
F=l=>
{
var x, z, s, q, D, R, Q, W;
// length of longest word in z
z = Math.max( ... l.map(w => w.length))
// sum of all words length in x
x = 0;
l.forEach(w => x += w.length);
for(; ++z <= x; ) // test square size from z to x
{
// grid in s[], each row of len z + 1 newline as separator, plus leading and trailing newline
// given z==offset between rows, total length of s is z*(z-1)+1
// gridsize: 2, z:3, s.length: 7
// gridsize: 3, z:4, s.length: 13
// ...
// All empty, nonseparator cells, filled with 1, so
// - valid cells have a truthy value (1 or string)
// - invalid cells have falsy value ('\n' or undefined)
s = Array(z*z-z+1).fill(1)
s = s.map((v,i) => i % z != 0 ? 1 : '\n');
// offset for 8 directions
D = [z+1, -z-1, 1-z, z-1, z, -z, 1, -1]; // 4 diags, then 2 vertical, then 2 horizontal
// Function to check repeating words
R = u => // return true if no repetition
! l.some( w => // for each word (exit early when true)
{
n = -1 -([...w]+''==[...w].reverse()); // counter starts at -1 or -2 if palindrome word
u.forEach( (a, p) => // for each cell if grid
{
if (a == [0]) // do check if cell == first letter of word, else next word
D.forEach( d => // check all directions
n += // word counter
[...w].every( c => // for each char in word, exit early if not equal
u[q += d] == c, // if word char == cell, continue to next cell using current offset
q = p-d // starting position for cell
)
) // end for each direction
} ) // end for each cell
return n > 0 // if n>0 the word was found more than once
} ) // end for each word
// Recursive function to fill empty space with random chars
// each call add a single char
Q =
( u,
p = u.indexOf(1), // position of first remaining empty cell
r = [...'ABCDEFGHIJHLMNOPQRSTUVWXYZ'] // char array to be random shuffled
) => {
if (~p) // proceed if p >= 0
return r.some((v,c)=>(r[u[p]=r[j=0|c+Math.random()*(26-c)],j]=v,R(u)&&Q(u)))||(u[p]=1)
else
return 1; // when p < 0, no more empty cells, return 1 as true
}
// Main working function, recursive fill of grid
W =
( k, // current word position in list
s, // grid
m, // bitmask with all directions used so far (8 H, 4V, 2 or 1 diag)
w = l[k] // get current word
) => {
var res = false
if (w) { // if current word exists
res = s.some((a,p)=>!!a&&
D.some((d,j,_,r=[...s],q=p-d)=>
[...w].every(c=>r[q+=d]==c?c:r[q]==1?r[q]=c:0)
&&R(r)&&W(k+1,r,m|1<<(j/2))
)
)
}
else
{ // word list completed, check additional constraints
if (m > 12 // m == 13, 14 or 15, means all directions used
&& Q(s) ) // try to fill with random, proceed if ok
{ // solution found !!
console.log(''+s) // output grid
z = x // z = x to stop outer loop
res = x//return value non zero to stop recursion
}
}
return res
};
W(0,s)
}
}
```
**Test** in Firefox/FireBug console
F(['TRAIN', 'CUBE','BOX','BICYCLE'])
```
,T,C,B,O,X,B,H,
,H,R,U,H,L,I,H,
,Y,A,A,B,E,C,B,
,D,H,S,I,E,Y,I,
,H,E,R,L,N,C,T,
,G,S,T,Y,F,L,U,
,H,U,Y,F,O,E,H,
```
*not filled*
```
,T,C,B,O,X,B, ,
, ,R,U, , ,I, ,
, , ,A,B, ,C, ,
, , , ,I,E,Y, ,
, , , , ,N,C, ,
, , , , , ,L, ,
, , , , , ,E, ,
```
F(['TRAIN','ARTS','RAT', 'CUBE','BOX','BICYCLE','STORM','BRAIN','DEPTH','MOUTH','SLAB'])
```
,T,A,R,C,S,T,H,
,S,R,R,L,U,D,T,
,T,B,A,T,N,B,P,
,O,B,O,I,S,A,E,
,R,B,A,X,N,H,D,
,M,R,M,O,U,T,H,
,B,I,C,Y,C,L,E,
```
F(['AA','AB','AC','AD','AE','AF','AG'])
```
,A,U,B,C,
,T,A,E,Z,
,C,D,O,F,
,Q,C,G,A,
```
F(['AA','AB','AC','AD','AE','AF'])
*output not filled* - @nathan: now you can't add another A*x* without repetitions. You'll need a bigger grid.
```
,A, ,C,
, ,A,F,
,D,E,B,
```
[Answer]
## C#
Here's a simple implementation with still work to be done.
There are very many combinations to get smallest size.
So just used simplest algorithm in could think of.
```
class Tile
{
public char C;
public int X, Y;
}
class Grid
{
List<Tile> tiles;
public Grid()
{
tiles = new List<Tile>();
}
public int MaxX()
{
return tiles.Max(x => x.X);
}
public int MaxY()
{
return tiles.Max(x => x.Y);
}
public void AddWords(List<string> list)
{
int n = list.Count;
for (int i = 0; i < n; i++)
{
string s = list[i];
if(i==0)
{
Vert(s, 0, 0);
}
else if(i==n-1)
{
int my = MaxY();
Diag(s, 0, my+1);
}
else
{
Horiz(s, 0, i);
}
}
}
private void Vert(string s, int x, int y)
{
for (int i = 0; i < s.Length; i++)
{
Tile t = new Tile();
t.C = s[i];
t.X = x+i;
t.Y = y;
tiles.Add(t);
}
}
private void Horiz(string s, int x, int y)
{
for (int i = 0; i < s.Length; i++)
{
Tile t = new Tile();
t.C = s[i];
t.X = x+i;
t.Y = y;
tiles.Add(t);
}
}
private void Diag(string s, int x, int y)
{
for (int i = 0; i < s.Length; i++)
{
Tile t = new Tile();
t.C = s[i];
t.X = x++;
t.Y = y++;
tiles.Add(t);
}
}
public void Print()
{
int mx = this.MaxX();
int my = this.MaxY();
int S = Math.Max(mx, my) + 1;
char[,] grid = new char[S, S];
Random r = new Random(DateTime.Now.Millisecond);
//fill random chars
for (int i = 0; i < S; i++)
{
for (int j = 0; j < S; j++)
{
grid[i, j] = (char)(r.Next() % 26 + 'A');
}
}
//fill words
tiles.ForEach(t => grid[t.X, t.Y] = t.C);
//print
for (int i = 0; i < S; i++)
{
for (int j = 0; j < S; j++)
{
Console.Write("{0} ", grid[i,j]);
}
Console.WriteLine();
}
}
}
class WordSearch
{
public static void Generate(List<string>list)
{
list.Sort((x, y) =>
{ int s = 0; if (x.Length < y.Length)s = -1; else if (y.Length < x.Length)s = 1; return s; });
list.Reverse();
Grid g = new Grid();
g.AddWords(list);
g.Print();
}
}
```
Test
```
class Program
{
static void Main(string[] args)
{
string words = "CAT, TRAIN, CUBE, BICYCLE";
string comma=",";
List<string> w = words.Split(comma.ToArray()).ToList();
List<string> t = new List<string>();
foreach(string s in w)
{
t.Add(s.Trim());
}
WordSearch.Generate(t);
Console.ReadKey();
}
}
```
] |
[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/109947/edit).
Closed 7 years ago.
[Improve this question](/posts/109947/edit)
Here's one generalized version of the famous [Eight Queen's Puzzle](https://en.wikipedia.org/wiki/Eight_queens_puzzle):
>
> Given an `n` × `n` chess board, and an integer `m` (≤ `n`). Find all possible ways to put `nm` Queens such that
>
>
> * there are `m` Queens at each **row**
> * there are `m` Queens at each **column**
>
>
> (note that we do not impose any restriction on the diagonals).
>
>
>
---
As you might see, it is possible, e.g. [`1` denotes a Queen]:
### `n` = 3, `m` = 2
```
1 1 0
0 1 1
1 0 1
```
### `n` = 15, `m` = 2
```
0 0 0 0 0 0 1 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0 0 0 1 0
1 0 0 0 0 0 0 0 0 0 0 0 0 1 0
1 0 1 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0 0 0 1 0 0 0
0 0 0 0 1 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 1 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0
0 0 0 0 0 0 0 0 0 0 1 0 1 0 0
```
---
**Input:** `n`, `m`
**Output:** Number of solutions
**Winning Criteria:** Single thread, Fastest [I will test with `n` = 15, `m` = 8 in my computer]
*Optional:* Print all solutions (as in the format given in examples)
*Preferred Language:* Python 2.7, Julia
Good luck!
]
|
[Question]
[
### Introduction
For the ones who don't know, a palindrome is when a string is equal to the string backwards (with exception to interpunction, spaces, etc.). An example of a palindrome is:
```
abcdcba
```
If you reverse this, you will end up with:
```
abcdcba
```
Which is the same. Therefore, we call this a palindrome. To palindromize things, let's take a look at an example of a string:
```
adbcb
```
This is not a palindrome. To palindromize this, we need to merge the reversed string into the initial string **at the right of the initial string**, leaving both versions intact. The shorter, the better.
The first thing we can try is the following:
```
adbcb
bcbda
^^ ^^
```
Not all characters match, so this is not the right position for the reversed string. We go one step to the right:
```
adbcb
bcbda
^^^^
```
This also doesn't match all characters. We go another step to the right:
```
adbcb
bcbda
```
This time, **all characters match**. We can *merge* both string *leaving the intact*. The final result is:
```
adbcbda
```
This is the *palindromized string*.
---
### The Task
Given a string (with at least one character) containing only **lowercase letters** (or uppercase, if that fits better), output the **palindromized string**.
---
### Test cases
```
Input Output
abcb abcba
hello hellolleh
bonobo bonobonob
radar radar
hex hexeh
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the least amount of bytes wins!
[Answer]
# Pyth (commit b93a874), 11 bytes
```
.VkI_IJ+zbB
```
[Test suite](https://pyth.herokuapp.com/?code=.VkI_IJ%2BzbB&test_suite=1&test_suite_input=abcb%0Abonobo%0Aradar%0Ahex&debug=0)
This code exploits a bug in the current version of Pyth, commit [b93a874](https://github.com/isaacg1/pyth/commit/b93a8740ed847dadfeab62e1b01db815d0d88775). The bug is that `_IJ+zb` is parsed as if it was `q_J+zbJ+zb`, which is equivalent to `_I+zb+zb`, when it should (by the design intention of Pyth) be parsed as `q_J+zbJ`, which is equivalent to `_I+zb`. This allows me to save a byte - after the bug is fixed, the correct code will be `.VkI_IJ+zbJB`. I'll explain that code instead.
Basically, the code brute forces over all possible strings until it finds the shortest string that can be appended to the input to form a palindrome, and outputs the combined string.
```
.VkI_IJ+zbJB
z = input()
.Vk For b in possible strings ordered by length,
+zb Add z and b,
J Store it in J,
_I Check if the result is a palindrome,
I If so,
J Print J (This line doesn't actually exist, gets added by the bug.
B Break.
```
[Answer]
## Python, 46 bytes
```
f=lambda s:s*(s==s[::-1])or s[0]+f(s[1:])+s[0]
```
If the string is a palindrome, return it. Otherwise, sandwich the first letter around the recursive result for the remainder of the string.
Example breakdown:
```
f(bonobo)
b f(onobo) b
b o f(nobo) o b
b o n f(obo) n o b
b o n obo n o b
```
[Answer]
## Haskell, 36 bytes
```
f s|s==reverse s=s|h:t<-s=h:f t++[h]
```
More readably:
```
f s
|s==reverse s = s
|(h:t)<-s = h:(f t)++[h]
```
If the string is a palindrome, return it. Otherwise, sandwich the first letter around the recursive result for the tail of the string.
The string `s` is split into `h:t` in the second guard, obviating a filler `1>0` for this case. This is shorter than doing `s@(h:t)` for the input.
[Answer]
# Jelly, ~~11~~ 10 bytes
```
ṫỤfU$Ḣœ^;U
```
[Try it online!](http://jelly.tryitonline.net/#code=4bmr4bukZlUk4biixZNeO1U&input=&args=aGVsbG8)
### How it works
```
ṫỤfU$Ḣœ^;U Main link. Argument: s (string)
Ụ Yield all indices of s, sorted by their corr. character values.
ṫ Tail; for each index n, remove all characters before thr nth.
This yields the list of suffixes of s, sorted by their first character,
then (in descending order) by length.
$ Combine the two links to the left into a chain:
U Upend; reverse all suffixes.
f Filter; only keep suffixes that are also reversed suffixes.
This gives the list of all palindromic suffixes. Since all of them
start with the same letter, they are sorted by length.
Ḣ Head; select the first, longest palindromic suffix.
œ^ Multiset symmetric difference; chop the selected suffix from s.
U Upend; yield s, reversed.
; Concatenate the results to the left and to the right.
```
[Answer]
# Pyth - ~~16~~ 12 bytes
*4 bytes saved thanks to @FryAmTheEggman.*
FGITW, much golfing possible.
```
h_I#+R_Q+k._
```
[Test Suite](http://pyth.herokuapp.com/?code=h_I%23%2BR_Q%2Bk._&input=%22adbcb%22&test_suite=1&test_suite_input=%22abcb%22%0A%22hello%22%0A%22bonobo%22%0A%22radar%22%0A%22hex%22&debug=0).
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~16~~ ~~6~~ 5 bytes (Non-competing)
```
:Ac.r
```
[Try it online!](http://brachylog.tryitonline.net/#code=OkFjLnI&input=ImJvbm9ibyI&args=Wg)
When I posted my initial answer, it was still on the old implementation in Java. Since I have reprogrammed everything in Prolog, it now works as it should have in the first place.
### Explanation
```
(?):Ac. Output is the concatenation of Input with another unknown string A
.r(.) The reverse of the Output is the Output
```
Backpropagation makes it so that the first valid value for `A` it will find will be the shortest that you can concatenate to Input to make it a palindrome.
### Alternate solution, 5 bytes
```
~@[.r
```
This is roughly the same as the above answer, except that instead of stating "Output is the concatenation of the Input with a string `A`", we state that "Output is a string for which the Input is a prefix of the Output".
[Answer]
## JavaScript (ES6), 92 bytes
```
(s,a=[...s],r=a.reverse().join``)=>s.slice(0,a.findIndex((_,i)=>r.startsWith(s.slice(i))))+r
```
Computes and slices away the overlap between the original string and its reversal.
[Answer]
# Retina, ~~29~~ 25
```
$
¶$_
O^#r`.\G
(.+)¶\1
$1
```
[Try it online!](http://retina.tryitonline.net/#code=JArCtiRfCk9eI3JgLlxHCiguKynCtlwxCiQx&input=Ym9ub2Jv)
Big thanks to [Martin](https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner) for 11 bytes saved!
This just creates a reversed copy of the string and smooshes them together. The only really fancy part of this is the reversing method: `O^#r`.\G`, which is done by using sort mode. We sort the letters of the second string (the ones that aren't newlines and are consecutive from the end of the string, thanks to the `\G`) by their numeric value, which, since there are no numbers, is 0. Then we reverse the order of the results of this stable sort with the `^` option. All credit for the fancy use of `\G` belongs to Martin :)
[Answer]
# CJam, 18
```
q__,,{1$>_W%=}#<W%
```
[Try it online](http://cjam.aditsu.net/#code=q__%2C%2C%7B1%24%3E_W%25%3D%7D%23%3CW%25&input=bonobo)
**Explanation:**
```
q read the input
__ make 2 copies
,, convert the last one to a range [0 … length-1]
{…}# find the first index that satisfies the condition:
1$> copy the input string and take the suffix from that position
_W%= duplicate, reverse and compare (palindrome check)
< take the prefix before the found index
W% reverse that prefix
at the end, the stack contains the input string and that reversed prefix
```
[Answer]
## Lua, ~~89~~ 88 Bytes
I beat the Javascript! \o/
**Saved 1 byte thanks to @LeakyNun ^^**
It's a full program, takes its input as command-line argument.
```
i=1s=...r=s:reverse()while s:sub(i)~=r:sub(0,#r-i+1)do i=i+1 end print(s..r:sub(#r-i+2))
```
## ungolfed
```
i=1 -- initialise i at 1 as string are 1-indexed in lua
s=... -- use s as a shorthand for the first argument
r=s:reverse() -- reverse the string s and save it into r
while(s:sub(i)~=r:sub(0,#r-i+1))-- iterate while the last i characters of s
do -- aren't equals to the first i characters of r
i=i+1 -- increment the number of character to skip
end
print(s..r:sub(#r-i+2)) -- output the merged string
```
[Answer]
# Prolog, 43 bytes
```
a(S):-append(S,_,U),reverse(U,U),writef(U).
```
This expects a codes string as input, e.g. on SWI-Prolog 7: `a(`hello`).`
### Explanation
This is basically a port of my Brachylog answer.
```
a(S) :- % S is the input string as a list of codes
append(S,_,U), % U is a list of codes resulting in appending an unknown list to S
reverse(U,U), % The reverse of U is U
writef(U). % Write U to STDOUT as a list of codes
```
[Answer]
# Octave, ~~78~~ 75 bytes
Saved 3 bytes thanks to Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ!
```
function p=L(s)d=0;while~all(diag(s==rot90(s),d++))p=[s fliplr(s(1:d))];end
```
ideone still fails for named functions, but [here](http://ideone.com/JSDPVJ) is a test run of the code as a program.
[Answer]
# Perl, 37 bytes
Based on xnor's answer.
Includes +2 for `-lp`
Run with input on STDIN, e.g.
```
palindromize.pl <<< bonobo
```
`palindromize.pl`:
```
#!/usr/bin/perl -lp
s/.//,do$0,$_=$&.$_.$&if$_!~reverse
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 2 bytes
```
Ṙ⋎
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLhuZjii44iLCIiLCJyYWNlYyJd)
```
⋎ # Merge on longest prefix/suffix with...
Ṙ # Input reversed
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 18 bytes
Code:
```
©gF¹ðN×®«ðñD®åi,q
```
Uses **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=w4LCqWdGwrnDsE7Dl8KuwqvDsMOxRMKuw6VpLHE&input=Ym9ub2Jv)
[Answer]
## Pyke, 15 bytes
```
D_Dlhm>m+#D_q)e
```
[Try it here!](http://pyke.catbus.co.uk/?code=D_Dlhm%3Em%2B%23D_q%29e&input=radar)
[Answer]
## J, 20 bytes
```
,[|.@{.~(-:|.)\.i.1:
```
This is a monadic verb. [Try it here.](http://tryj.tk) Usage:
```
f =: ,[|.@{.~(-:|.)\.i.1:
f 'race'
'racecar'
```
## Explanation
I'm using the fact that the palindromization of **S** is **S + reverse(P)**, where **P** is the shortest prefix of **S** whose removal results in a palindrome.
In J, it's a little clunky to do a search for the first element of an array that satisfies a predicate; hence the indexing.
```
,[|.@{.~(-:|.)\.i.1: Input is S.
( )\. Map over suffixes of S:
-: Does it match
|. its reversal? This gives 1 for palindromic suffixes and 0 for others.
i.1: Take the first (0-based) index of 1 in that array.
[ {.~ Take a prefix of S of that length: this is P.
|.@ Reverse of P.
, Concatenate it to S.
```
[Answer]
## Haskell, 68 bytes
```
import Data.List
f i=[i++r x|x<-inits i,i++r x==x++r i]!!0
r=reverse
```
Usage example: `f "abcb"` -> `"abcba"`.
Search through the `inits` of the input `i` (e.g. `inits "abcb"` -> `["", "a", "ab", "abc", "abcb"]`) until you find one where it's reverse appended to `i` builds a palindrome.
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), ~~17~~ 16 bytes
Loosely inspired in [@aditsu's CJam answer](https://codegolf.stackexchange.com/a/77103/36398).
```
`xGt@q:)PhttP=A~
```
[**Try it online!**](http://matl.tryitonline.net/#code=YHhHdEBxOilQaHR0UD1Bfg&input=J2Jvbm9ibyc)
### Explanation
```
` % Do...while loop
x % Delete top of stack, which contains a not useful result from the
% iteration. Takes input implicitly on first iteration, and deletes it
G % Push input
t % Duplicate
@q: % Generate range [1,...,n-1], where n is iteration index. On the first
% iteration this is an empty array
) % Use that as index into copy of input string: get its first n elements
Ph % Flip and concatenate to input string
t % Duplicate. This will be the final result, or will be deleted at the
% beginning of next iteration
tP % Duplicate and flip
=A~ % Compare element-wise. Is there some element different? If so, the
% result is true. This is the loop condition, so go there will be a
% new iteration. Else the loop is exited with the stack containing
% the contatenated string
% End loop implicitly
% Display stack contents implicitly
```
[Answer]
# Ruby, 44 bytes
This answer is based on xnor's [Python](https://codegolf.stackexchange.com/a/77116/47581) and [Haskell](https://codegolf.stackexchange.com/a/77115/47581) solutions.
```
f=->s{s.reverse==s ?s:s[0]+f[s[1..-1]]+s[0]}
```
[Answer]
# Oracle SQL 11.2, 195 bytes
```
SELECT MIN(p)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(p))FROM(SELECT:1||SUBSTR(REVERSE(:1),LEVEL+1)p FROM DUAL WHERE SUBSTR(:1,-LEVEL,LEVEL)=SUBSTR(REVERSE(:1),1,LEVEL)CONNECT BY LEVEL<=LENGTH(:1));
```
Un-golfed
```
SELECT MIN(p)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(p))
FROM (
SELECT :1||SUBSTR(REVERSE(:1),LEVEL+1)p
FROM DUAL
WHERE SUBSTR(:1,-LEVEL,LEVEL)=SUBSTR(REVERSE(:1),1,LEVEL)
CONNECT BY LEVEL<=LENGTH(:1)
);
```
[Answer]
## Seriously, 34 bytes
```
╩╜lur`╜╨"Σ╜+;;R=*"£M`MΣ;░p╜;;R=I.
```
The last character is a non-breaking space (ASCII 127 or `0x7F`).
[Try it online!](http://seriously.tryitonline.net/#code=4pWp4pWcbHVyYOKVnOKVqCLOo-KVnCs7O1I9KiLCo01gTc6jO-KWkXDilZw7O1I9SS5_&input=J2FkYmNiJw)
Explanation:
```
╩╜lur`╜╨"Σ╜+;;R=*"£M`MΣ;░p╜;;R=I.<NBSP>
╩ push inputs to registers (call the value in register 0 "s" for this explanation)
╜lur push range(0, len(s)+1)
` `M map (for i in a):
╜╨ push all i-length permutations of s
" "£M map (for k in perms):
Σ╜+ push s+''.join(k) (call it p)
;;R= palindrome test
* multiply (push p if palindrome else '')
Σ summation (flatten lists into list of strings)
;░ filter truthy values
p pop first element (guaranteed to be shortest, call it x)
╜;;R=I pop x, push s if s is palindromic else x
.<NBSP> print and quit
```
[Answer]
# C#, 202 bytes
I tried.
```
class P{static void Main(string[]a){string s=Console.ReadLine(),o=new string(s.Reverse().ToArray()),w=s;for(int i=0;w!=new string(w.Reverse().ToArray());){w=s.Substring(0,i++)+o;}Console.WriteLine(w);}}
```
Ungolfed:
```
class P
{
static void Main(string[] a)
{
string s = Console.ReadLine(), o = new string(s.Reverse().ToArray()), w = s;
for(int i = 0; w!=new string(w.Reverse().ToArray());)
{
w = s.Substring(0, i++) + o;
}
Console.WriteLine(w);
Console.ReadKey();
}
}
```
Can anyone provide me with any ideas to group the two calls to .Reverse().ToArray() ? A separate method is more bytes.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
Ṗ;¥ƤUŒḂƇḢ
```
[Try it online!](https://tio.run/##y0rNyan8///hzmnWh5YeWxJ6dNLDHU3H2h/uWPT/cPujpjWR//8rJSYlJynpKChlANXmgxhJ@Xn5SWBWUWJKYhFErgJEJaaA1AIA "Jelly – Try It Online")
## How it works
```
Ṗ;¥ƤUŒḂƇḢ - Main link. Takes a string S on the left
U - Reverse s
¥ - Group the previous 2 links into a dyad f(p, r):
Ṗ - Remove the last element of p
; - Concatenate the truncated p to r
Ƥ - Over each prefix p of s, yield f(p, rev(s))
Ƈ - Keep those for which the following is true:
ŒḂ - Is a palindrome?
Ḣ - Take the first
```
[Answer]
# [K (ngn/k)](https://bitbucket.org/ngn/k), 24 bytes
```
{t@*&{x~|x}'t:x,/:|',\x}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqrrEQUutuqKupqJWvcSqQkffqkZdJ6ai9n@auoZSYlJykpK1UkZqTk4@kE7Kz8tPAjGKElMSi8ASFUqa/wE "K (ngn/k) – Try It Online")
Feels like it could be golfed more...
* `,\x` make list of prefixes of input
* `t:x,/:\'` append the reverse of each prefix to the original input, storing in `t`
* `*&{x~|x}'` identify the index of the first item in the list that is a palindrome
* `t@` retrieve that list item and return it from the function
[Answer]
## [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 41 bytes
```
;_FA|C=A{a=a+1~C=_fC||_XC\C=A+right$(B,a)
```
Explanation:
```
;_FA| Read A$ from the cmd line, then flip it to create B$
C=A Set C$ to be A$
{ Start an infinite DO-loop
a=a+1 Increment a (not to be confused with A$...)
~C=_fC| If C$ is equal to its own reversed version
|_XC THEN end, printing C$
\C=A+ ELSE, C$ is reset to the base A$, with
right$(B the right part of its own reversal
,a) for length a (remember, we increment this each iteration
DO and IF implicitly closed at EOF
```
[Answer]
# Haskell, 46 bytes
```
f l|l==reverse l=l|(h:t)<-l=l!!0:(f$tail l)++[l!!0]
```
I'm wondering if there's a way to remove the parenthesis in `(f$tail l)++[l!!0]`...
] |
[Question]
[
Write a program that counts up forever, starting from one.
Rules:
* Your program must log to `STDOUT` or an acceptable alternative, if `STDOUT` is not available.
* Your program must be a full, runnable program, and not a function or snippet.
* Your program must output each number with a separating character in between (a newline, space, tab or comma), but this must be consistent for all numbers.
* You may print the numbers in decimal, [in unary](http://meta.codegolf.stackexchange.com/questions/5343/can-numeric-input-output-be-in-unary) or in [base 256 where each digit is represented by a byte value](http://meta.codegolf.stackexchange.com/questions/4708/can-numeric-input-output-be-in-the-form-of-byte-values).
* Your program must count at least as far as 2128 (inclusive) without problems and without running out of memory on a reasonable desktop PC. In particular, this means if you're using unary, you cannot store a unary representation of the current number in memory.
* Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge. Languages specifically written to submit a 0-byte answer to this challenge are fair game but not particularly interesting.
Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.
* This is not about finding the language with the shortest solution for this (there are some where the empty program does the trick) - this is about finding the shortest solution in every language. Therefore, no answer will be marked as accepted.
### Catalogue
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
## Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
## Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
## Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the snippet:
```
## [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 63834; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 39069; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>
```
[Answer]
## [Labyrinth](https://github.com/mbuettner/labyrinth), 5 bytes
```
):
\!
```
♫ The IP in the code goes round and round ♫
Relevant instructions:
```
) Increment top of stack (stack has infinite zeroes at bottom)
: Duplicate top of stack
! Output top of stack
\ Output newline
```
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 8 bytes
```
01+:nao!
```
Steps:
* Push 0 on the stack
* Add 1 to the top stack element
* Duplicate top stack element
* Output the top of the stack as number
* Output a newline
* Go to step 2 by wrapping around and jumping the next instruction (step 11)
*(A less memory efficient (hence invalid) program is `llnao`.)*
[Answer]
# C (64-bit architecture only), 53 bytes
Relies on pointers being at least 64 bits and prints them in hex using the `%p` specifier. The program would return right when it hits 2^128.
```
char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}
```
[Answer]
## Haskell, 21 bytes
```
main=mapM_ print[1..]
```
Arbitrary-precision integers and infinite lists make this easy :-)
Luckily `mapM_` is in the Prelude. If `Data.Traversable` was as well, we even could shrink it to 19 bytes:
```
main=for_[1..]print
```
[Answer]
# [Gol><>](https://golfish.herokuapp.com/), 3 bytes
```
P:N
```
Steps:
* Add 1 to the top stack element (at start it is an implicit 0)
* Duplicate top stack element
* Pop and output the top of the stack as number and a newline
* Wrap around to step 1 as we reached the end of the line
[Answer]
# [Marbelous](https://github.com/marbelous-lang/marbelous.py), ~~11450~~ 4632 bytes
Printing decimals is a pain!!
Definitely not winning with this one, but I thought I'd give it a shot. I hope it's ok that it pads the output to 40 zeros (to fit 2^128).
```
00@0..@1..@2..@3..@4..@5..@6..@7..@8..@9..@A..@B..@C..@D..@E..@F..@G..@H..@I..@J
\\++..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00
..EhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhun
....AddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddt
..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7\/
../\&8..........................................................................
....@0..........................................................................
....../\&8......................................................................
....//..@1......................................................................
........../\&8..................................................................
......////..@2..................................................................
............../\&8..............................................................
........//////..@3..............................................................
................../\&8..........................................................
..........////////..@4..........................................................
....................../\&8......................................................
............//////////..@5......................................................
........................../\&8..................................................
..............////////////..@6..................................................
............................../\&8..............................................
................//////////////..@7..............................................
................................../\&8..........................................
..................////////////////..@8..........................................
....................................../\&8......................................
....................//////////////////..@9......................................
........................................../\&8..................................
......................////////////////////..@A..................................
............................................../\&8..............................
........................//////////////////////..@B..............................
................................................../\&8..........................
..........................////////////////////////..@C..........................
....................................................../\&8......................
............................//////////////////////////..@D......................
........................................................../\&8..................
..............................////////////////////////////..@E..................
............................................................../\&8..............
................................//////////////////////////////..@F..............
................................................................../\&8..........
..................................////////////////////////////////..@G..........
....................................................................../\&8......
....................................//////////////////////////////////..@H......
........................................................................../\&8..
......................................////////////////////////////////////..@I..
............................................................................../\&8
........................................//////////////////////////////////////..@J
&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9
Sixteenbytedecimalprintermodulewitharegi
:Sixteenbytedecimalprintermodulewitharegi
}J}J}I}I}H}H}G}G}F}F}E}E}D}D}C}C}B}B}A}A}9}9}8}8}7}7}6}6}5}5}4}4}3}3}2}2}1}1}0}00A
/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A
%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..
:/A
..}0..}0..
..>>}0....
..>>>>\\..
....//..//
../\>>\\..
....>>..//
....>>\\..
....>>....
\\>>//....
..>>......
..>>......
../\......
..../\<<..
......<<..
..\\<<//..
....~~....
....++....
....\\..//
\\....>9\/
..\\..?0..
......++..
....\\....
......{0..
:%A
@0..
}0..
<A-A
{0@0
:Eg
}0}0}0}0}0}0}0}0
^7^6^5^4^3^2^1^0
~~....~~~~..~~~~
^0^0^0^0^0^0^0^0
{0{0{0{0{0{0{0{0
:Ehun
}0..}0
Eg..&0
=8&0{0
&1\/00
0100&0
&1&1{1
{1{0
:Addt
}0}1
{1{1
```
[Answer]
## [Hexagony](https://github.com/mbuettner/hexagony), ~~12~~ ~~11~~ ~~10~~ 7 bytes
*Thanks to alephalpha for fitting the code into side-length 2.*
```
10})!';
```
Unfolded:
```
1 0
} ) !
' ;
```
This one is fairly simple. `10` writes a 10, i.e. a linefeed to the initial memory edge. Then `})!';` is repeatedly executed in a loop:
* `}` move to the next memory edge.
* `)` increment it.
* `!` print it as an integer.
* `'` move back to the 10.
* `;` print it as a character.
I believe that this is optimal (although by far not unique). I've let the brute force script I wrote [for this answer](https://codegolf.stackexchange.com/a/62812/8478) search for 6-byte solutions under the assumption that it would have to contain at least one each of `;` and `!` and either `(` or `)`, and would not contain `?`, `,` or `@`, and it didn't find any solutions.
[Answer]
# bc, 10
```
for(;;)++i
```
Unusual that `bc` is shorter than [`dc`](https://codegolf.stackexchange.com/a/63861/11259).
From `man bc`:
>
> DESCRIPTION
>
>
> bc is a language that supports arbitrary precision numbers
>
>
>
[Answer]
# Pyth, 4 bytes
```
.V1b
```
### Explanation:
```
.V1 for b in range(1 to infinity):
b print b
```
[Answer]
# Java, ~~139~~ ~~138~~ ~~127~~ 123 bytes
```
class K{public static void main(String[]a){java.math.BigInteger b=null;for(b=b.ZERO;;)System.out.println(b=b.add(b.ONE));}}
```
[Answer]
# Mathematica, 22 bytes
```
i=0;While[Echo[++i]>0]
```
[`Echo`](http://reference.wolfram.com/language/ref/Echo.html) is a new function in Mathematica 10.3.
[Answer]
# Python 3, ~~33~~ 25 bytes
As far as I understand, Pythons integers are arbitrary precision, and `print()` automatically produces newlines.
Thanks for @Jakub and @Sp3000 and @wnnmaw! I really don't know much python, the only think I knew was that it supports arbitrary size integers=)
```
k=1
while 1:print(k);k+=1
```
[Answer]
# Ruby, ~~15~~ 12 bytes
```
loop{p$.+=1}
```
* `p`, when given an integer, prints the integer as-is (courtesy of [@philomory](https://codegolf.stackexchange.com/users/47276/philomory))
* `$.` is a magical variable holding the number of lines read from stdin. It is obviously initialized to 0, and also assignable :)
[Answer]
# [Samau](https://github.com/AlephAlpha/Samau), 2 bytes
```
N)
```
Explanation:
```
N push the infinite list [0 1 2 ...] onto the stack
) increase by 1
```
When the output of a program is a list, the outmost brackets are omitted.
[Answer]
# [Microsoft PowerPoint](https://www.youtube.com/watch?v=uNjxe8ShM-8) (33 Slides, 512 shapes to meet minimum requirements)
Storage representation is in hexadecimal.
## Directions
* Click the blue square to advance the counter (or propagate the carry), or make an AutoHotKey Script to click it for you.
* You can view the number's digits at any time using the green buttons. (It causes unintended behavior if you click the blue buttons after viewing another digit.) This is just for a better UX. It still counts up as normal as long as you keep clicking the blue button. In other words, no user decision is required.
* If you reach the end, it displays a congratulatory message.
You can get the PPTX [here](https://drive.google.com/open?id=1JTbg0fSnWV2ig7PYYb1jB5kWCteW9XgU). Requires PowerPoint to run.
Before you comment that Microsoft PowerPoint is not a programming language, it has been shown that PowerPoint is Turing complete (in the same sense that conventional languages such as C are Turing complete). A brief discussion is given [here](https://www.andrew.cmu.edu/user/twildenh/PowerPointTM/Paper.pdf).
[Answer]
# [makina](https://github.com/GingerIndustries/makina), 22 bytes
```
v
>Pv
^>OC
^Uu>n0;
^O<
```
I AM REAL HUMAN YOU SHOULD TRUST ME AND DO WHAT I SAY
[Answer]
# Matlab, 132 bytes
```
a=0;while 1;b=a==9;n=find(cumsum(b)-(1:numel(b)),1);a(n)=a(n)+1;a(1:n-1)=0;if ~numel(n);a=[0*a,1];end;disp([a(end:-1:1)+'0','']);end
```
Ok, I think this is the *first serious* answer that accomplishes this task without a trivial builtin abitrary size integer. This program implements an arbitrary size integer as an array of integers. Each integer is always between 0 and 9, so each array element represents one decimal digit. The array size wil be increased by one as soon as we are at e.g. `999`. The memory size is no problem here, as `2^128` only requires an array of length 39.
```
a=0;
while 1
b=a==9;
%first number that is not maxed out
n=find(cumsum(b)-(1:numel(b)),1);
%increase that number, and sett all maxed out numbers to zero
a(n)=a(n)+1;
a(1:n-1)=0;
if ~numel(n) %if we maxed out all entries, add another digit
a=[0*a,1];
end
disp([a(end:-1:1)+'0',''])%print all digits
end
```
[Answer]
# [Processing](http://www.processing.org), ~~95~~ ~~85~~ 71 bytes
```
java.math.BigInteger i;{i=i.ZERO;}void draw(){println(i=i.add(i.ONE));}
```
I tried something with a while loop but it causes all of Processing to crash, so I'll stick with this for now.
(Thanks to @SuperJedi224 and @TWiStErRob for suggestions.)
[Answer]
# JavaScript (ES6), ~~99~~ ~~94~~ 67 bytes
```
for(n=[i=0];;)(n[i]=-~n[i++]%10)&&alert([...n].reverse(i=0).join``)
```
`alert` is the generally accepted `STDOUT` equivalent for JavaScript but using it means that consecutive numbers are automatically separated. I've assumed that outputting a character after the number is not necessary because of this.
[Answer]
## C++, ~~146~~ ~~141~~ 138 bytes
Using a standard bigint library is perhaps the *most* boring way of answering this question, but someone had to do it.
```
#include<stdio.h>
#include<boost/multiprecision/cpp_int.hpp>
int main(){for(boost::multiprecision::uint512_t i=1;;){printf("%u\n",i++);}}
```
Ungolfed:
```
#include<cstdio>
#include<boost/multiprecision/cpp_int.hpp>
int main()
{
for(boost::multiprecision::uint512_t i=1;;)
{
std::printf("%u\n", i++);
}
}
```
The reason the golfed version uses `stdio.h` and not `cstdio` is to avoid having to use the `std::` namespace.
This is my first time golfing in C++, let me know if there's any tricks to shorten this further.
[Answer]
## Intel 8086+ Assembly, 19 bytes
```
68 00 b8 1f b9 08 00 31 ff f9 83 15 00 47 47 e2 f9 eb f1
```
Here's a breakdown:
```
68 00 b8 push 0xb800 # CGA video memory
1f pop ds # data segment
b9 08 00 L1: mov cx, 8 # loop count
31 ff xor di, di # ds:di = address of number
f9 stc # set carry
83 15 00 L2: adc word ptr [di], 0 # add with carry
47 inc di
47 inc di
e2 f9 loop L2
eb f1 jmp L1
```
It outputs the 128 bit number on the top-left 8 screen positions. Each screen position holds a 8-bit ASCII character and two 4 bit colors.
*Note: it wraps around at 2128; simply change the `8` in`mov cx, 8` to `9` to show a 144 bit number, or even `80*25` to show numbers up to 232000.*
## Running
### 1.44Mb bzip2 compressed, base64 encoded bootable floppy Image
Generate the floppy image by copy-pasting the following
```
QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=
```
into this commandline:
```
base64 -d | bunzip2 > floppy.img
```
and run with, for instance, `qemu -fda floppy.img -boot a`
### 1.8Mb bootable ISO
This is a base64 encoded bzip2 compressed ISO image. Generate the iso by pasting
```
QlpoOTFBWSZTWZxLYpUAAMN/2//fp/3WY/+oP//f4LvnjARo5AAQAGkAEBBKoijAApcDbNgWGgqa
mmyQPU0HqGCZDQB6mQ0wTQ0ZADQaAMmTaQBqekyEEwQaFA0AA0AxBoAAA9Q0GgNAGg40NDQ0A0Bi
BoDIAANNAA0AyAAABhFJNIJiPSmnpMQDJpp6nqeo0ZDQaAANB6IA0NAGj1EfIBbtMewRV0acjr8u
b8yz7cCM6gUUEbDKcCdYh4IIu9C6EIBehb8FVUgEtMIAuvACCiO7l2C0KFaFVABcpglEDCLmQqCA
LTCAQ5EgnwJLyfntUzNzcooggr6EnTje1SsFYLFNW/k+2BFABdH4c4vMy1et4ZjYii1FbDgpCcGl
mhZtl6zX+ky2GDOu3anJB0YtOv04YISUQ0JshGzAZ/3kORdb6BkTDZiYdBAoztZA1N3W0LJhITAI
2kSalUBQh60i3flrmBh7xv4TCMEHTIOM8lIurifMNJ2aXr0QUuLDvv6b9HkTQbKYVSohRPsTOGHi
isDdB+cODOsdh31Vy4bZL6mnTAVvQyMO08VoYYcRDC4nUaGGT7rpZy+J6ZxRb1b4lfdhtDmNwuzl
E3bZGU3JTdLNz1uEiRjud6oZ5kAwqwhYDok9xaVgf0m5jV4mmGcEagviVntDZOKGJeLjyY4ounyN
CWXXWpBPcwSfNOKm8yid4CuocONE1mNqbd1NtFQ9z9YLg2cSsGQV5G3EhhMXKLVC2c9qlqwLRlw4
8pp2QkMAMIhSZaSMS4hGb8Bgyrf4LMM5Su9ZnKoqELyQTaMAlqyQ3lzY7i6kjaGsHyAndc4iKVym
SEMxZGG8xOOOBmtNNiLOFECKHzEU2hJF7GERK8QuCekBUBdCCVx4SDO0x/vxSNk8gKrZg/o7UQ33
Fg0ad37mh/buZAbhiCIAeeDwUYjrZGV0GECBAr4QVYaP0PxP1TQZJjwT/EynlkfyKI6MWK/Gxf3H
V2MdlUQAWgx9z/i7kinChITiWxSo
```
into
```
base64 -d bunzip2 > cdrom.iso
```
and configure a virtual machine to boot from it.
### DOS .COM
This is a base64 encoded [DOS .COM](https://en.wikipedia.org/wiki/COM_file) executable:
```
aAC4H7kIADH/+YMVAEdH4vnr8Q==
```
Generate a .COM file using
```
/bin/echo -n aAC4H7kIADH/+YMVAEdH4vnr8Q== | base64 -d > COUNTUP.COM
```
and run it in (Free)DOS.
[Answer]
## sed, ~~116~~ ~~92~~ 83 bytes
```
:
/^9*$/s/^/0/
s/.9*$/_&/
h
s/.*_//
y/0123456789/1234567890/
x
s/_.*//
G
s/\n//p
b
```
**Usage:**
Sed operates on text input and it *needs* input do anything. To run the script, feed it with just one empty line:
```
$ echo | sed -f forever.sed
```
**Explanation:**
To increment a number, the current number is split up into a prefix and a suffix where the suffix is of the form `[^9]9*`. Each digit in the suffix is then incremented individually, and the two parts are glued back together. If the current number consists of `9` digits only, a `0` digit is appended, which will immediately incremented to a `1`.
[Answer]
## Clojure, 17 bytes
```
(map prn (range))
```
Lazy sequences and arbitrary precision integers make this easy (as for Haskell and CL). `prn` saves me a few bytes since I don't need to print a format string. `doseq` would probably be more idiomatic since here we're only dealing with side effects; `map` doesn't make a lot of sense to use since it will create a sequence of `nil` (which is the return value of each `prn` call.
Assuming I count forever, the null pointer sequence which results from this operation never gets returned.
[Answer]
## C# .NET 4.0, ~~111~~ ~~103~~ ~~102~~ 97 bytes
```
class C{static void Main(){System.Numerics.BigInteger b=1;for(;;)System.Console.WriteLine(b++);}}
```
I didn't find any C# answer here, so I just had to write one.
.NET 4.0 is required, because it's the first version that includes [BigInteger](https://msdn.microsoft.com/library/system.numerics.biginteger(v=vs.100).aspx). You have to reference [System.Numerics.dll](https://msdn.microsoft.com/en-us/library/system.numerics(v=vs.100).aspx) though.
With indentation:
```
class C
{
static void Main()
{
System.Numerics.BigInteger b = 1;
for (;;)
System.Console.WriteLine(b++);
}
}
```
*Thanks to sweerpotato, Kvam, Berend for saving some bytes*
[Answer]
# [MarioLANG](http://esolangs.org/wiki/MarioLANG), 11 bytes
```
+<
:"
>!
=#
```
Inspired by [Martin Büttner's answer in another question](https://codegolf.stackexchange.com/questions/62230/simple-cat-program/62425#62425).
[Answer]
## CJam, 7 bytes
```
0{)_p}h
```
Explanation:
```
0 e# Push a zero to the stack
{ e# Start a block
) e# Increment top of stack
_ e# Duplicate top of stack
p e# Print top of stack
} e# End block
h e# Do-while loop that leaves the condition on the stack
```
Note: Must use Java interpreter.
[Answer]
## C, 89 bytes
A new approach (implementing a bitwise incrementer) in C:
```
b[999],c,i;main(){for(;;)for(i=c=0,puts(b);i++<998;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}
```
**Less golfed**
```
int b[999], c, i;
main() {
for(;;)
for(i=c=0, puts(b); i++ < 998;)
putchar(48 + (c ? b[i] : (b[i] = c = !b[i])));
}
```
**Terminate**
This version has the slight flaw, that it does not terminate (which isn't a requirement at the moment). To do this you would have to add 3 characters:
```
b[129],c=1,i;main(){for(;c;)for(i=c=0,puts(b);i++<128;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}
```
[Answer]
# [Foo](http://esolangs.org/wiki/Foo), 6 bytes
```
(+1$i)
```
---
### Explanation
```
( ) Loop
+1 Add one to current element
$i Output current element as a decimal integer
```
[Answer]
# [Acc!](https://codegolf.stackexchange.com/a/62404), ~~64~~ 65 bytes
Also works in [*Acc!!*](https://codegolf.stackexchange.com/a/62493).
```
Count q while 1 {
Count x while q-x+1 {
Write 7
}
Write 9
}
```
This prints the numbers out in unary using [Bell characters](https://en.wikipedia.org/wiki/Bell_character) seperated by tabs. If I have to use a more standard character, that would make the program **66 bytes**.
The Acc! interpreter provided in the linked answer translates Acc! to Python, which does support arbritrary-precision integers.
[Answer]
## [Minkolang](https://github.com/elendiastarman/Minkolang), 4 bytes
```
1+dN
```
[Try it here.](http://play.starmaninnovations.com/minkolang/?code=1%2BdN) (Well, actually, be careful. 3 seconds of run time was enough to get up to ~40,000.)
`1+` adds 1 to the top of stack, `d` duplicates it, and `N` outputs the top of stack as an integer with a trailing space. This loops because Minkolang is toroidal, so when the program counter goes off the right edge, it reappears on the left.
] |
[Question]
[
Your bird has been itching for some exercise and is sick of being stuck in static positions all the time. Write a program that will show a randomly dancing ascii bird, updating every 100ms\*n or 200ms\*n depending on the dance move. The bird always begins with the dance move `<(")>`.
The program should accept one input which is a number to multiply the sleep interval by (`n >= 0 && n <= 50`).
**100ms Moves**
```
^(")v
v(")^
^(")^
v(")v
```
**200ms Moves**
```
(>")>
<(")>
<("<)
```
## Extra Details
* Randomness doesn't have to be uniform but each dance move should have a reasonable chance of occuring (at least 1 in 60 seems fair, it's OK if the same move occurs twice in a row)
* There should only be one bird displayed at a time, not multiple birds
* Trailing whitespace is allowed (but other trailing characters are not)
* A bird should be displayed *before* the sleep
## Example in Python 3
```
import random, time, sys
birds = """(>")>
<(")>
<("<)
^(")v
v(")^
^(")^
v(")v"""
birds = birds.split()
interval = int(input("Sleep for 100ms*"))
selection = -1
while True:
if selection == -1:
selection = 1
else:
selection = random.randint(0, len(birds)-1)
sys.stdout.write('\r'+birds[selection])
if selection > 2:
time.sleep(0.1*interval)
else:
time.sleep(0.2*interval)
```
## Winning
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so least bytes wins!
[Answer]
# Matlab, ~~125~~ 117 bytes
Unfortunately this cannot be displayed in TIO as there is no "streaming" of the output. Here's a gif for an input of `1` instead:
```
t=input('')*.1;a='^(")vv(")^^(")^v(")v(>")><(")><("<)';while 1;n=randi(7);clc;disp(a(n*5-4:n*5));pause(t+t*(n>4));end
```
Thanks @LuisMendo for -8 bytes!
[Answer]
## [\*><>](https://esolangs.org/wiki/Starfish), ~~103~~ 101 bytes
```
<vD[3'(")'
1x<.5
S\:43_C43CdooI:o@:o@:o@Do
R!"^"x"v">
>:2* _"><"92.
x '>)">('u.02S*2:oooooodO<'<("<)'
```
[Try it here!](https://starfish.000webhostapp.com/?script=DwNwIg2gzA5AFAIgJQwFAEYAewB0BWVAZQB0AuAFigH0BhSmgEwHsmBJUpgAQ+67CdQAlAIQIAegkwIQCAHypZpAEwAqAARU5wBAE4lOVJjUxZSOXBgBXHAAYlhFUo4sXDAPLAYwRMBRA) (write in `n` on the initial stack or you'll get an error)
I decided to take a stab at my challenge since there were no sub 100 bytes answers. Place `n` on the stack and away you go! This reuses the `(")` characters to save some bytes.
# Explanation
## Initialisation
`<vD[3'(")'`
Here we store `(")` for later usage.
```
< move the IP left
[3'(")' push '(")' to a new stack
D move back down to a clean stack
v move the IP down into "dance chooser"
```
## Dance chooser
```
1x<.5
\
```
This is frequently executed to select which type of dance we're going to generate.
```
x generate a 100ms dance or a 200ms dance
1 .5 jump to "200ms dance"
\ mirror IP into "100ms dance"
```
There's a `v` above the `x` and a `<` to the right of it too. These make the `x` get re-executed if it tries to move the IP in the wrong direction.
## Generate 100ms dance
```
S\:1*43_C43CdooI:o@:o@:o@Do
```
Here we generate and output one of the 100ms dance moves.
```
\ mirror the IP right
: copy n
43 C43C call "generate '^' or 'v'" twice
_ ignored mirror
do output a carriage return
o output the first hand of the bird
I:o@:o@:o@D select, copy, and output '(")'
o output the second hand of the bird
S sleep for previous n*100ms
\ mirror IP back to "dance chooser"
```
### 43C - Generate "^" or "v"
```
R!"^"x"v">
```
This is a simple function that generates "^" or "v" then returns. It works similarly to the dance chooser where it has instructions around `x` to ensure the IP only moves left or right.
```
x generate "^" or "v"
R!"^" > push "^" to stack and return
R "v" push "v" to stack and return
```
## Generate 200ms dance
This is another that begins with `x`. It'll be separated into two sections: `<(")>` and another `(>")> and <("<)`, because they're two distinct sections and `x` is the only thing they share.
### `<(")>`
```
>:2* _"><"b2.
```
This basically does the beginning of the `generate 100ms dance` routine, but populates the bird hands as `><` instead of a random `^v` combo. It multiplies `n` by two this time as well. This makes it all setup to utilise the `generate 100ms dance` routine to output the entire bird and wait 200ms instead.
```
> move IP right
:2* copy n and do n*2
_ ignored mirror
"><" push "><" to stack
b2. jump to "output carriage return" in "generate 100ms dance"
```
### `(>")>` and `<("<)`
```
x '>)">('u.02S*2:oooooodO<'<("<)'
```
This little explanation is about the `(>")>` and `<("<)` generation, though the `x` can send the IP outside of it (explained below).
```
x move to "choose dance", generate (>")>, <("<), or <(")> (previous routine)
'>)">(' push '(>")>' to the stack
'<("<)' push '<("<)' to the stack
u O< ensure inner code block is always executed with IP moving left
od output carriage return
ooooo output bird
S*2: sleep for n*200ms
.02 jump to "dance chooser"
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 53 bytes
```
xXx`'./U;HbG#3@@!{uu'F'v^<>(")'Za7e 7YrY)D5M3>QG*&XxT
```
Moves are uniformly random.
Below is a sample run with`n = 2`. Or try it at [**MATL Online!**](https://matl.io/?code=xXx%60%27.%2FU%3BHbG%233%40%40%21%7Buu%27F%27v%5E%3C%3E%28%22%29%27Za7e+7YrY%29D5M3%3EQG%2a%26XxT&inputs=2&version=19.7.0) (The interpreter is experimental. If it doesn't run initially try pressing "Run" again or refreshing the page).
[](https://i.stack.imgur.com/9n5mk.gif)
### Explanation
```
x % Take input n and delete it
Xx % Clear screen
` % Do...while
'./U;HbG#3@@!{uu' % Push this (compressed) string
F % Specify source alphabet for decompression
'v^<>(")' % Push target alphabet
Za % Base conversion (decompress)
7e % Reshape as a 7-row char matrix. Each row is a move
7Yr % Push random integer from 1 to 7
Y) % Select that row from the char matrix
D % Display it
5M % Push the integer again
3> % Does it exceed 3? Gives false (0) or true (1)
Q % Add 1
G* % Multiply by n
&Xx % Pause that many tenths of a second and clear screen
T % Push true
% End (implicit). Since top of the stack is true, this causes
% and infinite loop
```
[Answer]
# JavaScript (ES6) + HTML5: ~~118~~ 116 + 8 = 124 bytes
## Javascript: 119 bytes
```
f=n=>{a.innerHTML='(>")>0<(")>0<("<)0^(")v0v(")^0^(")^0v(")v'.split(0)[r=+new Date%7],setTimeout(f,(1+(r<3))*100*n,n)}
```
I'm using the milliseconds since epoch to generate a random-ish number. Theoretically, this would always generate the same (set of) number(s), but a test on my PC gave me a pretty random outcome (most numbers appeared more or less equally). Also using the fact that html elements with an id get added to the global window object in JavaScript, so `document.getElementById()` is not needed.
## HTML: 8 bytes
```
<b id=a>
```
I'm omitting the quotes here and I'm not closing the `b` tag. It's not valid html, but all browsers automatically close the tag anyway. I made it bold because `b` is a one-character HTML element and because my bird's dance deserves being noticed.
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), ~~124~~ 117 bytes
(Thanks [TimmyD](https://codegolf.stackexchange.com/users/42963/timmyd))
```
for(){(-split'^(")v v(")^ ^(")^ v(")v (>")> <(")> <("<)')[($i=0..6|random)];sleep -m((100,200)[$i-gt3]*$args[0]);cls}
```
[Try it online!](https://tio.run/nexus/powershell#LchLCoMwEADQqwQJOCONjApuYr1ISEBalUD8kEg22rOnRbp5i5emzQOeIMLu7JEbyDCy@NMwcxvvgT7DnnXwt8McFXD7pLJsLz@s721BLYMbx52JBaAietREqLgV89Hogg9@Doo0ypcLn5S@ "PowerShell – TIO Nexus") (Not that it will work in TIO...)
[Answer]
# [Noodel](https://tkellehe.github.io/noodel/), noncompeting 67 [bytes](https://tkellehe.github.io/noodel/docs/code_page.html)
```
ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð
ḊḢðḞ’ṀḌcṀḌcİ8c¬ððɲḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ
```
This challenge was very difficult for *Noodel* because it does not have any smart arithmetic or comparative based operators. But after doing this challenge, I think *Noodel* is ready for its first release.
[Try it:)](https://tkellehe.github.io/noodel/release/editor-0.0.html?code=%CA%A0%C6%98%E1%B9%A3%E1%B8%B3%C6%91%C3%B0%E1%BA%89%E1%B8%A4%C5%BC%E2%80%99%E1%B9%80%E1%BB%B4(E%E1%B8%9E4%C4%8A%E1%B8%8C%E1%B9%80Y%25%C2%A4%C4%A0%E1%BA%B8G%5E%E1%B8%9E%C3%B0x%E1%BB%8C%C3%B0%0A%E1%B8%8A%E1%B8%A2%C3%B0%E1%B8%9E%E2%80%99%E1%B9%80%E1%B8%8Cc%E1%B9%80%E1%B8%8Cc%C4%B08c%C2%AC%C3%B0%C3%B0%C9%B2%E1%B8%B7%E1%B9%9B%E1%B8%8B%CA%A0%E1%B9%A1%CA%A0%E1%BA%A1%C3%87%C6%A5%C6%A5%E1%BA%A1%C6%A5%E1%B8%8B%CA%A0%E2%81%BA%C2%B5%E1%B8%8D&input=2&run=true)
## How It Works
```
# Note: The input is immediately pushed onto the stack.
ʠ # Moves the pointer for the top of the stack down one.
ƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð # Creates a string based off of the key "ƘṣḳƑðẉḤż" and the compressed text "ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð" to create "^(")vðv(")^ð^(")^ðv(")vð(>")>ð<(")>ð<("<)" which then gets split by the null character "ð" to create an array of strings which gets pushed to the stack.
\n # A new line to separate the literals.
ḊḢðḞ’ṀḌcṀḌcİ8c¬ðð # Creates a string based off of the key "ḊḢðḞ" and the compressed text "ṀḌcṀḌcİ8c¬ðð" to create "100ð100ð100ð100ð200ð200ð200" which then gets split the same way as before.
ɲ # Turns each element in the array into a number creating the array of delays.
ḷ # Loops the rest of the code unconditionally.
ṛ # Generates a random number from 0 to the length-1 of the array on top of the stack.
ḋ # Duplicates the random number.
ʠ # Moves the stack pointer down to save one of the random numbers for later.
ṡ # Swap the array with the random number such that the array is on top again.
ʠ # Moves the stack pointer down such that the random number is on top.
ạ # Uses the random number to access the bird array which is now after the random number and pushes the element onto the stack.
Ç # Clears the screen and pops the bird and pushes it to the screen.
ƥƥ # Moves the stack pointer up two times such that the random number is the top.
ạ # Use the random number to access the array with delays and pushes that item onto the stack.
ƥ # Moves the stack pointer up in order to have the input on top.
ḋ # Duplicates the users input.
ʠ # Moves the stack pointer back down in order to have the user input on top followed by the random item from the delay array.
⁺µ # This command pops two numbers off and multiplies them and pushes the result back on.
ḍ # Pops off of the stack and uses that as a delay in milliseconds.
```
---
**64 bytes**
Here is a version that works as a code snippet.
```
ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð EAð¶’Ṁ|ṢĿ<h4¶¬ȥḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ
```
```
<div id="noodel" code="ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð EAð¶’Ṁ|ṢĿ<h4¶¬ȥḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ" input="2" cols="5" rows="3"></div>
<script src="https://tkellehe.github.io/noodel/release/noodel-1.1.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>
```
[Answer]
# Python, 157 bytes
```
import time,random;n,m=5,int(input())
while 1:print('(>")><(")><("<)^(")vv(")^^(")^v(")v'[n:n+5]);time.sleep((.1+(n<15)/10)*m);n=(n+random.randint(1,6)*5)%35
```
I also tried to do it without the chicken ascii art, but that was way longer.
```
import time,random;n,m=5,int(input())
while 1:
print(['^v'[n%2]+'(")'+'v^'[0<n<3],''.join(map(chr,[40+20*(n>4),62-22*(n>4),34,41+19*(n>5),62-21*(n>5)]))][n>3])
time.sleep((.1+(n>3)/10)*m);n=(n+random.randint(1,6))%7
```
[Answer]
# Ruby, 97+1 = 98 bytes
+1 byte from the `-n` flag.
```
a=1;loop{puts %w{^(")v <(")> v(")^ (>")> ^(")^ <("<) v(")v}[a];sleep$_.to_i*0.1*(1+a%2);a=rand 7}
```
[Answer]
## Clojure, ~~185~~ 178 bytes
+18 bytes because it wasn't starting with `<(")>`.
-7 bytes by inlining `birds`, and getting rid of the `let`.
```
#(loop[m nil r(or m 1)](print"\r"((clojure.string/split"(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v"#" ")r))(flush)(Thread/sleep(*(if(> r 2)100 200)%))(recur 1(rand-int 7)))
```
Just splits the birds on spaces, picks a random index from 0-6, displays the chosen bird, then if the chosen index is greater than 2, it waits for 100ms, else 200ms.
Clojure really needs a string `split` method in the core.
Ungolfed:
```
(defn dancing-bird [n]
(loop [m nil]
(let [birds (clojure.string/split "(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v" #" ")
rand-i (or m 1)]
(print "\r" (birds rand-i))
(flush)
(Thread/sleep (* (if (> r 2) 100 200) n))
(recur (rand-int 7)))))
```
] |
[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/103422/edit).
Closed 7 years ago.
[Improve this question](/posts/103422/edit)
# Challenge
Create a program that will build a recursive list of all linked webpages (given a starting point), to a depth determined by user input.
*Any valid link in the HTML should be crawled, whether or not it is a script, image, etc.*
# Example Input
```
<program name> <url to crawl> <depth>
webcrawler http://crawlthissite.com/mypage.html 2
```
# Example Output
```
http://crawlthissite.com/book1
http://crawlthissite.com/book2
http://crawlthissite.com/book1/1.html
http://crawlthissite.com/book2/1.html
http://site.net
http://coolsite.com/
http://coolsite.com/about.html
http://coolsite.com/shop.html
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest answer (in bytes) wins.
P.S. this is my first code-golf, please don't get mad if I have broken the rules of the site in any way, please just let me know.
]
|
[Question]
[
Inspired by [this](http://www.smbc-comics.com/index.php?db=comics&id=2874). There is a number, given as either integer, string or array of digits (your choice). Find the base in which the representation of the number will have most "4"s and return that base.
```
Number Result
624 5
444 10
68 16
```
restrictions:
* The base returned should not be greater than the input.
* Numbers less than or equal to 4 should not be considered valid input, so undefined returns are acceptable
[Answer]
## APL (~~31~~ 19)
Now tests all possible bases.
```
⊃⍒{+/4=K⊤⍨K⍴⍵}¨⍳K←⎕
```
Explanation:
* `⍳K←⎕`: read user input, store in K. Make a list from 1 to K, which are the bases to try.
* `{`...`}¨`: for each of these, run the following function
* `K⊤⍨K⍴⍵`: encode K into that base giving a list of digits (as numbers) per base. Use K digits (a big overestimate, but it doesn't matter because the unused ones will all be zero anyway).
* `4=`: see which of these are equal to 4
* `+/`: sum these, now we know how many fours per base
* `⊃⍒`: give the indices of the list if it were sorted downwards, so the index of the biggest one is at the front. Take the first item of this list.
[Answer]
### GolfScript, 30 characters
```
.,{[2+.2$\base{4=},,\]}%$)~p];
```
Works for any base - test the code [online](http://golfscript.apphb.com/?c=OzYyNAoKLix7WzIrLjIkXGJhc2V7ND19LCxcXX0lJCl%2BcF07Cg%3D%3D&run=true).
*Comment:* This solution was based on the original version of the question. It thus may return a base larger than the input, e.g. for the input 4 it correctly returns base 5 - which is no longer valid by the new rules.
[Answer]
## Python 2.x, 77 chars
```
F=lambda x:max((sum(x/b**d%b==4for d in range(99)),b)for b in range(5,99))[1]
```
Works up to base 98 and numbers at most 98 digits long.
[Answer]
## J, 38 characters
```
f=.[:(i.>./)[:+/[:|:4=(10#"0(i.37))#:]
```
Usage:
```
p 624
5
p 444
10
p 68
16
```
[Answer]
## VBA, 121
```
Function k(a)
For w=5 To a
Z=0:q=a:Do:c=q Mod w:Z=Z-(c=4):q=Int(q/w):Loop Until q=0
If Z>x Then x=Z:k=w
Next
End Function
```
usage:
* direct window: `?k(num)`
* Excel formula: `=k(A1)`
[Answer]
## GolfScript (23 chars)
```
~:^,2>{^\base[4]/,~}$0=
```
or
```
~:^,2>{^\base[4]/,}$-1=
```
or
```
~:^,2>{^\base[4]/,}$)\;
```
Note that this takes input from stdin: for a fair comparison with Howard's GolfScript version subtract one char.
---
Howard points out that the rules have changed, and it's not very logical that they now exclude `4` as a possible input when it has a valid output (any integer greater than 4). To cover that case as well requires an extra 2 characters, which can be added in all kinds of ways:
```
~:^)),2>{^\base[4]/,}$)\;
```
or
```
~:^,{))^\base[4]/,}$)))\;
```
being a couple of the obvious ones.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
bⱮċ€4M
```
[Try it online!](https://tio.run/##y0rNyan8/z/p0cZ1R7ofNa0x8f1/uB1I//9vZmSiY2JiomNmoWNoBgA "Jelly – Try It Online")
Outputs "all" bases up to N which gives the most 4's. If you want maximal or minimal base, add `Ṁ` (max) or `Ṃ` (min) respectively.
### How it works
```
bⱮċ€4M Main link (monad). Input: integer N.
bⱮ Convert N to each base of 1..N
ċ€4 Count 4's in each representation
M Take maximal indices
```
[Answer]
# Mathematica 59
**Code**
```
Sort[{Count[IntegerDigits[n, #], 4], #} & /@ Range[5, 36]][[-1, 2]]
```
Let's give the above function a name.
```
whichBase[n_] := Sort[{Count[IntegerDigits[n, #], 4], #} & /@ Range[2, 36]][[-1, 2]]
```
**Explanation**
1. `Count[IntegerDigits[n,k],4]`: Count the number of fours in the base *k* representation of *n*.
2. `Sort` the bases from fewest to most 4s.
3. Return the base from the last item in the list, that is, the base that had the representation with the most 4's.
**Some special numbers**
Now let's apply whichBase to the following special numbers.
```
numbers= {1953124, 8062156, 26902404, 76695844, 193710244, 444444444,
943179076, 1876283764, 3534833124, 6357245164, 10983816964,
18325193796, 29646969124, 46672774204, 71708377284, 107789473684,
158856009316, 229956041484, 327482302084, 459444789604, 635782877604,
868720588636, 1173168843844, 1567178659764, 2072449425124,
2714896551724, 3525282954756, 4539918979204, 5801435550244,
7359635486844, 9272428079044, 11606852190676}
```
>
> {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, \
> 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36}
>
>
>
If you convert each number to the corresponding base, you will see what is special about them.
[Answer]
# Japt `-h`, 10 bytes
`444` in base `10` is `[4,4,4]` which contains the number *and* digit `4` 3 times but `444` in base `100` is `[4,44]` which also contains the digit `4` 3 times, but only as a number once. Given the expected output in the challange for the `444` test case, I'd guess we're supposed to be counting the number 4:
```
õ ñ@ìX è¥4
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=9SDxQOxYIOilNA==&input=NDQ0Ci1o)
But if we *are* counting the digit 4 then:
```
õ ñ@ìX ¬è4
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=9SDxQOxYIKzoNA==&input=NDQ0Ci1o)
```
õ :Range [1,...,input]
ñ@ :Sort by passing each X through a function
ìX : Convert the input to a base X digit array
:(VERSION 1)
è : Count the elements
¥4 : Equal to 4
:(VERSION 2)
¬ : Join to a string
è4 : Count the occurrences of "4"
:Implicitly output the last element in the sorted array
```
[Answer]
# C - (114 characters)
In all it's golfy glory:
```
x,k,c,d,n;main(v){scanf("%d",&v);for(k=5;v/k;++k){x=v;c=0;while(x)c+=x%k==4,x/=k;c>=d?n=k,d=c:0;}printf("%d",n);}
```
And somewhat ungolfed:
```
x,k,c,d,n; // declare a bunch of ints, initialized to 0
main(v){ // declare one more, without using an extra comma
scanf("%d",&v); // get the input (v)
for(k=5;v/k;++k){ // loop over each base (k) greater than or equal to (/)
// our input (v)
x=v; // temp value (x) set to input (v)
c=0; // number of 4s in the current base (c) re-initialized
while(x) // loop over our temp until it's used up
c+=x%k==4, // if the next digit (x%k) is 4 (==4) increment the
// current count (c+=)
x/=k; // remove the current digit
c>=d?n=k,d=c:0; // if the number of 4s in this base (c) is greater
// than the current maximum number of 4s (d), then
// save the new best base (n), and new maximum
// number of 4s
}
printf("%d",n); // output the result
}
```
Just for fun here's the output for the numbers `[0,127]` (these are the largest bases under the input number itself).
>
> 0, 0, 0, 0, 0, 5, 6, 7, 8, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 5, 21, 22, 23, 6, 25, 26, 27, 7, 29, 30, 31, 8, 33, 34, 35, 9, 37, 38, 39, 10, 41, 42, 43, 11, 5, 46, 47, 12, 49, 50, 51, 13, 53, 54, 55, 14, 57, 58, 59, 15, 61, 62, 63, 16, 65, 66, 67, 17, 69, 5, 71, 18, 73, 74, 75, 19, 7, 78, 79, 20, 81, 82, 83, 21, 85, 86, 87, 22, 89, 90, 91, 23, 93, 94, 5, 24, 97, 98, 99, 25, 101, 102, 103, 26, 5, 106, 107, 27, 109, 5, 111, 28, 113, 114, 5, 29, 9, 5, 5, 5, 121, 122, 123
>
>
>
[Answer]
**R - ~~148~~ 137 chars**
(so, far away from the rest of the competition but still)
```
f=function(n){s=sapply;which.max(s(lapply(strsplit(s(4:n,function(x){q=n;r="";while(q){r=paste(q%%x,r);q=q%/%x};r})," "),`==`,4),sum))+3}
```
Basically transform the input from base 10 to all bases from 4 to n (using modulo `%%` and integer division `%/%`) and pick the index of the first one having the most 4s.
```
f(624)
[1] 5
f(444)
[1] 10
```
[Answer]
J translation of @marinus' APL solution:
```
NB. Expression form (22 characters, not including "n" - the "argument"):
{.\:(+/@(4=$#:[)"0 i.)n
NB. Function form (24 characters, not including "f=:"):
f=:{.@\:@(+/@(4=$#:[)"0 i.)
```
Just for interest, here are some values:
```
(,.f"0)9+i.24
9 5
10 6
11 7
12 8
13 9
14 5
15 11
16 6
17 13
18 7
19 5
20 5
21 5
22 5
23 5
24 5
25 6
26 6
27 6
28 6
29 5
30 7
31 7
32 7
```
It outputs the smallest base that gives a fouriest transform. For the last few values in the table, the representations look like “4n” (e.g 31 in base 7 is “43”).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~10~~ 9 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
LBε4¢}Zk>
```
-1 byte thanks to *@Cowabunghole*.
If multiple bases have the same amount of 4s, it will output the smallest one (i.e. `16` will result in `6`, but `12` would also have been a possible output).
[Try it online](https://tio.run/##yy9OTMpM/f/fx@ncVpNDi2qjsu3@/zczMgEA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVnl4gr2SwqO2SQpK9v99nM5tNTm0qDYq2@6/zn8zIxMuExMTLjMLLkMzAA).
**Explanation:**
```
L # Create a list in the range [1, (implicit) input]
# i.e. 624 → [1,2,3,...,622,623,634]
B # Convert the (implicit) input integer to Base-N for each N in this list
# i.e. 624 and [1,2,3,...,622,623,624]
# → ["1","1001110000","212010",...,"12","11","10"]
ε } # Map this list to:
4¢ # Count the number of 4s in the number
# → [0,0,0,0,4,0,0,0,0,1,0,2,...,0,0,0]
Z # Take the max (without popping the list)
# i.e. [0,0,0,0,4,0,0,0,0,1,0,2,...,0,0,0] → 4
k # Get the index of this max in the list
# i.e. [0,0,0,0,4,0,0,0,0,1,0,2,...,0,0,0] and 4 → 4
> # Increase it by to convert the 0-index to our base (and output implicitly)
# i.e. 4 → 5
```
[Answer]
# [k](https://en.wikipedia.org/wiki/K_programming_language), 18 bytes
```
{*>+/'4=x{y\x}'!x}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqlrLTltf3cS2oroypqJWXbGi9n@aupmRiYKJiYmCmcV/AA "K (ngn/k) – Try It Online")
```
{ } /function(x)
x '!x /for every y in 0, 1, ..., (x-1):
{y\x} / do x in base y
4= /see which digits equal four
+/' /sum, to get number of 4s per base
*> /get index (which equals base) of largest number of 4s
```
[Answer]
**C# with Linq 273**
```
using System;using System.Linq;class P{static void Main(){int r,z,k=int.Parse(Console.ReadLine());if(k<=4) return;Console.WriteLine(Enumerable.Range(4, k).Select(x =>{r = 0;z = k;while (z > 0){if(z % x==4){r++;}z/=x;}return new[]{r, x};}).OrderBy(n => n[0]).Last()[1]);}}
```
or
```
using System;
using System.Linq;
class P
{
static void Main()
{
int r, z, k = int.Parse(Console.ReadLine());
if (k <= 4) return;
Console.WriteLine(
Enumerable.Range(4, k).Select(x =>
{
r = 0;
z = k;
while (z > 0)
{
if (z % x == 4)
{
r++;
}
z /= x;
}
return new[] { r, x };
}).OrderBy(n => n[0]).Last()[1]);
}
}
```
Pretty sure the number of variables can be reduced and the if's can be converted to ?s. Oh well...
[Answer]
C# (482 ~423 Bytes)
First attempt at a 'golfed' solution. I used basically the same algorithm as the VBA above. I could probably save some bytes inlining the conversion function, or shortening the name. Like I said this is a first attempt, so please be gentle.
With whitespace:
```
using System;
class Program
{
static void Main(string[] args)
{
int n = int.Parse(args[0]);
int c=0, m=0;
string r="";
int t = 0;
for (int i = 5; i < 37; i++)
{
while (n > 0)
{
r = (char)((int)(n % i) + 48 + (7 * ((int)(n % i) > 9 ? 1 : 0))) + r;
n = (int)(n / i);
}
t = r.Length - r.Replace("4", "").Length;
if (t > c) { c = t; m = i; }
}
Console.WriteLine("Base: " + m);
}
}
```
[Answer]
## Burlesque - 28 bytes
```
Jbcjro{dg}Z]J{4CN}Cmsb[~Fi?i
Jbcjro create a list 1..input and convert input
to an infinite list.
{dg}Z] convert number to base (zipWith operation)
J duplicate
{4CN}Cm create comparison function
4CN count the number of fours.
sb sort by
[~ take the last element (which is going to be
the base-n representation where count of fours
is highest)
Fi Find the index of this last element in the original
unsorted list
?i increment (because base 1 is index 0)
```
[Try it online.](https://tio.run/##SyotykktLixN/a9jZmTy3yspOasovzolvTYq1qvaxNmv1jm3OCm6zi3TPvP/fwA)
[Answer]
# [Perl 6](http://perl6.org/), 44 bytes
```
{max 5..$^a,by=>{grep 4,$a.polymod($_ xx*)}}
```
[Try it online!](https://tio.run/##DccxCoAgAAXQq3xEokIcwiQIO0phpC2JYosint1aHrxg4iOby@gsVCtOJ8yc012zM6ut3NEECEY1D/7Jzl89PZDSONTaXp1B/qoNxYIelcD6CDkJBiF@5LK2Dw "Perl 6 – Try It Online")
Good old [polymod](https://docs.perl6.org/routine/polymod).
[Answer]
# [Husk](https://github.com/barbuz/Husk), 9 bytes
```
S€►#4ṠMBḣ
```
[Try it online!](https://tio.run/##AR0A4v9odXNr//9T4oKs4pa6IzThuaBNQuG4o////zYyNA "Husk – Try It Online")
```
€ The 1-based index in
MB the list of the input's representations in every base
Ṡ ḣ from 1 to itself
S ► of its element which has the largest
# number of
4 fours.
```
[Answer]
# [Julia](http://julialang.org/), 50 bytes
```
n->sort(2:n+1,by=b->-sum(digits(n,base=b).==4))[1]
```
[Try it online!](https://tio.run/##LcrBCsIwDADQe76ixxbXYkccMkh/ZOyw4iaVmcmSgX59PejxwXsca5niuy5U2SfZdrVtz6fY5A9ln7wcT3sr96JiucmTzJRdIELnhjhWnUXFkBmguwIiQtcixP5yhhHgtRfWlYP9rUDJLH84V78 "Julia 1.0 – Try It Online")
] |
[Question]
[
You are given, as a list or vector or whatever, a bunch of 3-tuples or whatever, where the first two things are strings, and the third thing is a number. The strings are cities, and the number is the distance between them. The order of the cities in the tuple is arbitrary (i.e. it doesn't matter which comes first and which comes second) since it is the same distance each way. Also, there is exactly one tuple for each pair of connected cites. Not all cities may be connected. Also, the distance is always positive (not `0`). You do not need to check these conditions, you may assume input will be well formed. Your job is to return the cities in a cyclic sequence, such that, if you start at any one city, and go around the sequence back to the same city, the total of the distances between the cities will be minimum (exactly and in all cases.) You may assume a solution exists. For example, let us say you are given
```
[("New York", "Detroit", 2.2), ("New York", "Dillsburg", 3.7), ("Hong Kong", "Dillsburg", 4), ("Hong Kong", "Detroit", 4), ("Dillsburg", "Detroit", 9000.1), ("New York", "Hong Kong", 9000.01)]
```
You could output any of the following (but you only need to output one):
```
["Detroit","Hong Kong","Dillsburg","New York"]
["Hong Kong","Dillsburg","New York","Detroit"]
["Dillsburg","New York","Detroit","Hong Kong"]
["New York","Detroit","Hong Kong","Dillsburg"]
["Dillsburg","Hong Kong","Detroit","New York"]
["New York","Dillsburg","Hong Kong","Detroit"]
["Detroit","New York","Dillsburg","Hong Kong"]
["Hong Kong","Detroit","New York","Dillsburg"]
```
because it is the shortest trip: 13.9
but not
```
["Dillburg","Detroit","New York","Hong Kong"]
```
because it is not the shortest.
See [en.wikipedia.org/wiki/Travelling\_salesman\_problem](http://en.wikipedia.org/wiki/Travelling_salesman_problem)
**Scoring**
This is where it gets interesting. You take the number of characters you have, and then plug them into the bare worst case O-notation formula. For example, let us say you write a brute force program that is 42 characters. As we all know, the worst case is `n!` where `n` is the number of cities. 42!=1405006117752879898543142606244511569936384000000000, so that is your score. The **lowest score wins**.
Note: I relieved this afterwards too, but wasn't sure how to solve it and hoped that no one would notice. People did, so I will go with issacg's suggestion:
>
> the only options are O(n!) and O(b^n*n^a*ln(n)^k), and all bounds must
> be as tight as possible given that notation
>
>
>
[Answer]
# Haskell, 259
I thought I would be able to get it shorter. maybe I will.
this has time complexity of O(n^2\*2^n)\* so score is about 6.2e82
\*i'm not actually sure, but if there is any "addition" to the complexity it's not more than polynomial, so this shouldn't change the score much.
```
import Data.List
g e=tail$snd$minimum[r|r@(_,b)<-iterate(\l->nubBy((.f).(==).f)$sort[(b+d,c:a)|(b,a)<-l,c<-h\\init a,d<-a!!0%c])[(0,[h!!0])]!!length h,b!!0==h!!0]where h=sort$nub$e>>= \(a,b,_)->[a,b];a%b=[z|(x,y,z)<-e,x==a&&y==b||x==b&&y==a]
f(_,x:b)=x:sort b
```
[Answer]
# Python 2, 237 231 228 225 characters
Since this is a naive algorithm, its score is probably about 225! ≈ 1.26e433.
```
from itertools import*
a=input()
n=lambda*a:tuple(sorted(a))
d=dict((n(*x[:2]),x[2])for x in a)
print min(permutations(set(chain(*[x[:2]for x in a]))),key=lambda x:sum(d.get(n(x[i],x[i+1]),1e400)for i in range(-1,len(x)-1)))
```
[Answer]
# Julia, 213 chars
Probably goes like `n!n`, so ~2e407.
```
a=[("New York", "Detroit", 2.2), ("New York", "Dillsburg", 3.7), ("Hong Kong", "Dillsburg", 4), ("Hong Kong", "Detroit", 4), ("Dillsburg", "Detroit", 9000.1), ("New York", "Hong Kong", 9000.01)]
f(a)=(
d(x,y)=(r=filter(z->x in z&&y in z,a);r==[]?Inf:r[1][3]);
m=Inf;
q=0;
c=unique([[z[1] for z=a],[z[2] for z=a]]);
n=length(c);
for p=permutations(c);
x=sum([d(p[i],p[mod1(i+1,n)]) for i=1:n]);
x<m&&(m=x;q=p);
end;
q)
f(a)
```
For readability and to demonstrate use I left in some unscored newlines and tabs as well as example input and a call to the function. Also I used an algorithm that requires `n!` time, but not `n!` memory, its slightly more feasible to run.
[Answer]
# Python 3 - 491
I did not count the length of the input graph variable `g`. This solution uses dynamic programming, and has a complexity of n^2 \* 2^n, for a total score of ~6.39e147. I am still pretty new to golfing, so please chime in if you see a big waste of code somewhere!
```
g=[("New York", "Detroit", 2.2), ("New York", "Dillsburg", 3.7), ("Hong Kong", "Dillsburg", 4), ("Hong Kong", "Detroit", 4), ("Dillsburg", "Detroit", 9000.1), ("New York", "Hong Kong", 9000.01)]
s=''
c={s:1}
D={}
for t in g:c[t[0]]=1;c[t[1]]=1;D[(t[0],t[1])]=t[2];D[(t[1],t[0])]=t[2];D[('',t[0])]=0;D['',t[1]]=0
V={}
y=[x for x in c.keys() if x!='']
f=''
def n(z,p):
if(len(p)==len(y)-1):
global f;f=z
if(0==len(p)):
return (D[(z,f)] if (z,f) in D else float('inf'))
Y=[(float('inf'),'')]
for P in p:
if((z,P) in D):
Y.append((D[(z,P)] + n(P,[m for m in p if m!=P]), P))
V[(z,tuple(p))]=min(Y)
return min(Y)[0]
n('',y)
for i in range(len(c)-1):
N=V[(s,tuple(y))][1]
print(N)
s=N
y.remove(N)
```
[Answer]
## Mathematica, 66 bytes
```
Most@Last@FindShortestTour@Graph[#<->#2&@@@#,EdgeWeight->Last/@#]&
```
No idea on the complexity, so the score is somewhere between `10^23` and `10^93`.
[Answer]
# Ruby, ~~198~~ 180 bytes
```
G=eval(gets.tr("()","[]"))
C=G.map{|t|[t[0],t[1]]}.flatten.uniq
D=Hash.new(+1.0/0)
G.map{|p|D[[p[0],p[1]]]=D[[p[1],p[0]]]=p[2]}
p C.permutation.map{|l|d=0;p=l[-1];l.map{|c|d+=D[[p,c]];p=c};[d,l]}.sort[0][1]
```
The first line that reads the input is unscored, as that seems to be what everyone else is doing. Also, there is no final newline needed for ruby.
It just dumbly generates all permutations of cities, so put me down for `O(n!*n)`. Actually, on second thoughts, it's slower even than that, because it sorts all `O(n!)` paths rather than keeping track of the best so far.
] |
[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 7 years ago.
[Improve this question](/posts/100571/edit)
Write a program that outputs as many characters as possible, with two conditions:
* The program must be 256 bytes or shorter
* The program must [almost surely](https://en.wikipedia.org/wiki/Almost_surely) eventually halt. In other words, the only thing not permitted in response to this question is an infinite loop.
For the purposes of this problem, any built-in psudo-random number generators will be treated as though they actually produce true random numbers. Even if it takes a really long time (years, centuries, or millennia) to compile, the program MUST BE a valid program in your language (and it must compile in a finite amount of time).
The program which produces the longest textual output before halting wins!!! (This means you must provide an approximate number of the expected length of output).
**A note on arbitrary-precision arithmatic:** No use of built-in arbitrary precision arithmetic capabilities.
]
|
[Question]
[
[The Sierpinsky Triangle](http://en.wikipedia.org/wiki/Sierpinski_triangle) is a fractal created by taking a triangle, decreasing the height and width by 1/2, creating 3 copies of the resulting triangle, and place them such each triangle touches the other two on a corner. This process is repeated over and over again with the resulting triangles to produce the Sierpinski triangle, as illustrated below.
Write a program to generate a Sierpinski triangle. You can use any method you want to generate the pattern, either by drawing the actual triangles, or by using a random algorithm to generate the picture. You can draw in pixels, ascii art, or whatever you want, so long as the output looks similar to the last picture shown above. Fewest characters wins.
[Answer]
## HTML + JavaScript, 150 characters (see notes for 126 characters)
Whitespace inserted for readability and not counted.
```
<title></title><canvas></canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>
```
The core of it is applying the rule of coloring pixels for which `x & y == 0` by the conditional `x&y||`, which produces a “Sierpinski right triangle”; and `x-~y/2,k-y` are a coordinate transformation to produce the approximately equilateral display.
A less correct (HTML-wise) version is 126 characters:
```
<canvas><script>
for(x=k=128;x--;)for(y=k;y--;)
x&y||document.body.firstChild.getContext("2d").fillRect(x-~y/2,k-y,1,1)
</script>
```
(The way in which this is less correct is that it omits the `title` element and the end tag of the `canvas` element, both of which are required for a correct document even though omitting them does not change the *interpretation* of the document.)
Three characters can be saved by eliminating `k` in favor of the constant `64`, at the cost of a smaller result; I wouldn't count the `8` option as it has insufficient detail.
Note that a size of 256 or higher requires attributes on the `<canvas>` to increase the canvas size from the default.
[Answer]
## GolfScript (43 42 chars)
```
' /\ /__\ '4/){.+\.{[2$.]*}%\{.+}%+\}3*;n*
```
Output:
```
/\
/__\
/\ /\
/__\/__\
/\ /\
/__\ /__\
/\ /\ /\ /\
/__\/__\/__\/__\
/\ /\
/__\ /__\
/\ /\ /\ /\
/__\/__\ /__\/__\
/\ /\ /\ /\
/__\ /__\ /__\ /__\
/\ /\ /\ /\ /\ /\ /\ /\
/__\/__\/__\/__\/__\/__\/__\/__\
```
Change the "3" to a larger number for a larger triangle.
[Answer]
**Mathematica - 32 characters**
```
Nest[Subsuperscript[#,#,#]&,0,5]
```
**Mathematica - 37 characters**
```
Grid@CellularAutomaton[90,{{1},0},31]
```
This will produce a 2D table of 0 and 1, where 1s are drawing Sierpinski Triangle.
[Answer]
# Python (234)
Maximal golfing, tiny image:
```
#!/usr/bin/env python3
from cairo import*
s=SVGSurface('_',97,84)
g=Context(s)
g.scale(97,84)
def f(w,x,y):
v=w/2
if w>.1:f(v,x,y);f(v,x+w/4,y-v);f(v,x+v,y)
else:g.move_to(x,y);g.line_to(x+v,y-w);g.line_to(x+w,y);g.fill()
f(1,0,1)
s.write_to_png('s.png')
```
Requires `python3-cairo`.
To get a nice large image I needed **239** characters.
[Answer]
## Python, 101 86
Uses the rule 90 automaton.
```
x=' '*31
x+='.'+x
exec"print x;x=''.join(' .'[x[i-1]!=x[i-62]]for i in range(63));"*32
```
This is longer, but prettier.
```
x=' '*31
x+=u'Δ'+x
exec u"print x;x=''.join(u' Δ'[x[i-1]!=x[i-62]]for i in range(63));"*32
```
Edit: playing with strings directly, got rid of obnoxiously long slicing, made output prettier.
Output:
```
Δ
Δ Δ
Δ Δ
Δ Δ Δ Δ
Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ Δ
```
[Answer]
## J
```
,/.(,~,.~)^:6,'o'
```
Not ideal, since the triangle is lopsided and followed by a lot of whitespace - but interesting nonetheless I thought.
Output:
```
o
oo
o o
oooo
o o
oo oo
o o o o
oooooooo
o o
oo oo
o o o o
oooo oooo
o o o o
oo oo oo oo
o o o o o o o o
oooooooooooooooo
o o
oo oo
o o o o
oooo oooo
o o o o
oo oo oo oo
o o o o o o o o
oooooooo oooooooo
o o o o
oo oo oo oo
o o o o o o o o
oooo oooo oooo oooo
o o o o o o o o
oo oo oo oo oo oo oo oo
o o o o o o o o o o o o o o o o
oooooooooooooooooooooooooooooooo
o o
oo oo
o o o o
oooo oooo
o o o o
oo oo oo oo
o o o o o o o o
oooooooo oooooooo
o o o o
oo oo oo oo
o o o o o o o o
oooo oooo oooo oooo
o o o o o o o o
oo oo oo oo oo oo oo oo
o o o o o o o o o o o o o o o o
oooooooooooooooo oooooooooooooooo
o o o o
oo oo oo oo
o o o o o o o o
oooo oooo oooo oooo
o o o o o o o o
oo oo oo oo oo oo oo oo
o o o o o o o o o o o o o o o o
oooooooo oooooooo oooooooo oooooooo
o o o o o o o o
oo oo oo oo oo oo oo oo
o o o o o o o o o o o o o o o o
oooo oooo oooo oooo oooo oooo oooo oooo
o o o o o o o o o o o o o o o o
oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo oo
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
```
**A quick explanation:**
The verb `(,~,.~)` is what's doing the work here. It's a [hook](http://www.jsoftware.com/help/primer/hook.htm) which first stitches `,.` the argument to itself (`o` -> `oo`) and then appends the original argument to the output:
```
oo
```
becomes
```
oo
o
```
This verb is repeated 6 times `^:6` with the output of each iteration becoming the input of the next iteration. So
```
oo
o
```
becomes
```
oooo
o o
oo
o
```
which in turn becomes
```
oooooooo
o o o o
oo oo
o o
oooo
o o
oo
o
```
etc. I've then used the oblique adverb on append `,/.` to read the rows diagonally to straighten(ish) the triangle. I didn't need to do this, as [randomra](https://codegolf.stackexchange.com/users/7311/randomra) points out. I could have just reversed `|.` the lot to get the same result. Even better, I could have just used `(,,.~)^:6,'o'` to save the reverse step completely.
Ah well, you live and learn. :-)
[Answer]
# 8086 Machine code - 30 bytes.
NOTE: This is **not my code and should not be accepted as an answer**. I found this while working on a different CG problem [to emulate an 8086 CPU](https://codegolf.stackexchange.com/questions/4732/emulate-an-intel-8086-cpu/9044#9044). The included text file credits **David Stafford**, but that's the best I could come up with.
I'm posting this because it's clever, short, and I thought you'd want to see it.
It makes use of overlapping opcodes to pack more instructions in a smaller space. Amazingly clever. Here is the machine code:
```
B0 13 CD 10 B3 03 BE A0 A0 8E DE B9 8B 0C 32 28 88 AC C2 FE 4E 75 F5 CD 16 87 C3 CD 10 C3
```
A straight-up decode looks like this:
```
0100: B0 13 mov AL, 13h
0102: CD 10 int 10h
0104: B3 03 mov BL, 3h
0106: BE A0 A0 mov SI, A0A0h
0109: 8E DE mov DS, SI
010B: B9 8B 0C mov CX, C8Bh
010E: 32 28 xor CH, [BX+SI]
0110: 88 AC C2 FE mov [SI+FEC2h], CH
0114: 4E dec SI
0115: 75 F5 jne/jnz -11
```
When run, when the jump at 0x0115 happens, notice it jumps back to 0x010C, right into the middle of a previous instruction:
```
0100: B0 13 mov AL, 13h
0102: CD 10 int 10h
0104: B3 03 mov BL, 3h
0106: BE A0 A0 mov SI, A0A0h
0109: 8E DE mov DS, SI
010B: B9 8B 0C mov CX, C8Bh
010E: 32 28 xor CH, [BX+SI]
0110: 88 AC C2 FE mov [SI+FEC2h], CH
0114: 4E dec SI
0115: 75 F5 jne/jnz -11
010C: 8B 0C mov CX, [SI]
010E: 32 28 xor CH, [BX+SI]
0110: 88 AC C2 FE mov [SI+FEC2h], CH
0114: 4E dec SI
0115: 75 F5 jne/jnz -11
010C: 8B 0C mov CX, [SI]
```
Brilliant! Hope you guys don't mind me sharing this. I know it's not an answer per se, but it's of interest to the challenge.
Here it is in action:
[Answer]
## Python (42)
I originally wanted to post a few suggestions on [boothbys solution](https://codegolf.stackexchange.com/a/6310/4626) (who actually uses rule 18 :), but i didn't have enough reputation to comment, so i made it into another answer. Since he changed his approach, i added some explanation.
My suggestions would have been:
1. use '%d'\*64%tuple(x) instead of ''.join(map(str,x)
2. shift in zeros instead of wraping the list around
which would have led to the following code (93 characters):
```
x=[0]*63
x[31]=1
exec"print'%d'*63%tuple(x);x=[a^b for a,b in zip(x[1:]+[0],[0]+x[:-1])];"*32
```
But i optimzed further, first by using a longint instead of an integer array and just printing the binary representation (75 characters):
```
x=2**31
exec"print'%d'*63%tuple(1&x>>i for i in range(63));x=x<<1^x>>1;"*32
```
And finally by printing the octal representation, which is already supported by printf interpolation (42 characters):
```
x=8**31
exec"print'%063o'%x;x=x*8^x/8;"*32
```
All of them will print:
```
000000000000000000000000000000010000000000000000000000000000000
000000000000000000000000000000101000000000000000000000000000000
000000000000000000000000000001000100000000000000000000000000000
000000000000000000000000000010101010000000000000000000000000000
000000000000000000000000000100000001000000000000000000000000000
000000000000000000000000001010000010100000000000000000000000000
000000000000000000000000010001000100010000000000000000000000000
000000000000000000000000101010101010101000000000000000000000000
000000000000000000000001000000000000000100000000000000000000000
000000000000000000000010100000000000001010000000000000000000000
000000000000000000000100010000000000010001000000000000000000000
000000000000000000001010101000000000101010100000000000000000000
000000000000000000010000000100000001000000010000000000000000000
000000000000000000101000001010000010100000101000000000000000000
000000000000000001000100010001000100010001000100000000000000000
000000000000000010101010101010101010101010101010000000000000000
000000000000000100000000000000000000000000000001000000000000000
000000000000001010000000000000000000000000000010100000000000000
000000000000010001000000000000000000000000000100010000000000000
000000000000101010100000000000000000000000001010101000000000000
000000000001000000010000000000000000000000010000000100000000000
000000000010100000101000000000000000000000101000001010000000000
000000000100010001000100000000000000000001000100010001000000000
000000001010101010101010000000000000000010101010101010100000000
000000010000000000000001000000000000000100000000000000010000000
000000101000000000000010100000000000001010000000000000101000000
000001000100000000000100010000000000010001000000000001000100000
000010101010000000001010101000000000101010100000000010101010000
000100000001000000010000000100000001000000010000000100000001000
001010000010100000101000001010000010100000101000001010000010100
010001000100010001000100010001000100010001000100010001000100010
101010101010101010101010101010101010101010101010101010101010101
```
Of course there is also a graphical solution (131 characters):
```
from PIL.Image import*
from struct import*
a=''
x=2**31
exec"a+=pack('>Q',x);x=x*2^x/2;"*32
fromstring('1',(64,32),a).save('s.png')
```
:D
[Answer]
## Haskell (291)
I'm not very good at golfing haskell codes.
```
solve n = tri (putStrLn "") [2^n] n
tri m xs 1 =
do putStrLn (l1 1 xs "/\\" 0)
putStrLn (l1 1 xs "/__\\" 1)
m
tri m xs n=tri m' xs (n-1)
where m'=tri m (concat[[x-o,x+o]|x<-xs]) (n-1)
o=2^(n-1)
l1 o [] s t=""
l1 o (x:xs) s t=replicate (x-o-t) ' '++s++l1 (x+2+t) xs s t
```
Output of `solve 4` is:
```
/\
/__\
/\ /\
/__\/__\
/\ /\
/__\ /__\
/\ /\ /\ /\
/__\/__\/__\/__\
/\ /\
/__\ /__\
/\ /\ /\ /\
/__\/__\ /__\/__\
/\ /\ /\ /\
/__\ /__\ /__\ /__\
/\ /\ /\ /\ /\ /\ /\ /\
/__\/__\/__\/__\/__\/__\/__\/__\
```
[Answer]
**QBasic 151 Characters**
As an example, here is how it can be done in QBasic.
```
SCREEN 9
H=.5
P=300
FOR I=1 TO 9^6
N=RND
IF N > 2/3 THEN
X=H+X*H:Y=Y*H
ELSEIF N > 1/3 THEN
X=H^2+X*H:Y=H+Y*H
ELSE
X=X*H:Y=Y*H
END IF
PSET(P-X*P,P-Y*P)
NEXT
```
[Answer]
## APL (51)
```
A←67⍴0⋄A[34]←1⋄' ○'[1+32 67⍴{~⊃⍵:⍵,∇(1⌽⍵)≠¯1⌽⍵⋄⍬}A]
```
Explanation:
* `A←67⍴0`: A is a vector of 67 zeroes
* `A[34]←1`: the 34th element is 1
* `{...}A`: starting with A, do:
* `~⊃⍵:`: if the first element of the current row is zero
* `⍵,∇`: add the current row to the answer, and recurse with:
* `(1⌽⍵)≠¯1⌽⍵`: the vector where each element is the XOR of its neighbours in the previous generation
* `⋄⍬`: otherwise, we're done
* `32 67⍴`: format this in a 67x32 matrix
* `1+`: add one to select the right value from the character array
* `' ○'[`...`]`: output either a space (not part of the triangle) or a circle (when it is part of the triangle)
Output:
```
○
○ ○
○ ○
○ ○ ○ ○
○ ○
○ ○ ○ ○
○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○
○ ○ ○ ○
○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
○ ○
○ ○ ○ ○
○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○ ○
```
[Answer]
# 80x86 Code / MsDos - 10 Bytes
As a sizecoder specialized for very tiny intros on MsDos i managed to come up with a program that occupies only 10 bytes.
in hex:
```
04 13 CD 10 20 E9 B4 0C E2 F6
```
[](https://i.stack.imgur.com/XIOJV.gif)
in asm:
```
X: add al,0x13
int 0x10
and cl,ch
mov ah,0x0C
loop X
```
The first version i coded was "Colpinski" which is 16 bytes in size, and even interactive in a way that you can change the color with the keyboard and the mouse. Together with "Frag" - another sizecoder - we brought that one down to 13 bytes, allowing for a 10 byte program which just contains the core routine.
It gets a bit more interesting when things are animated, so i'll mention another version, [Zoompinski 64](http://www.pouet.net/prod.php?which=67594) - trying to mimic the exact behavior of "Zoompinski C64" in 512 bytes - also for MsDos, 64 bytes in size as the name suggests.
It's possible to optimize this further downto 31 Bytes, while losing elegance, colors and symmetry (source and executable available behind the link above)
[Download the original and comment on "Pouet"](http://www.pouet.net/prod.php?which=62079)
[Answer]
## C ~~127~~ ~~119~~ ~~116~~ ~~108~~ 65
This one uses the trick of the HTML answer of `^ i & j` getting it to print pretty output would take 1 more char (you can get really ugly output by sacrificing the `a^`).
```
a=32,j;main(i){for(;++i<a;)putchar(a^i&j);++j<a&&main(puts(""));}
```
To make it pretty turn `(32^i&j)` to `(32|!(i&j))` and turn it from `++i<a` to `++i<=a`. However wasting chars on looks seems ungolfish to me.
Ugly output:
```
! ! ! ! ! ! ! ! ! ! ! ! ! ! !
"" "" "" "" "" "" "" ""
"# !"# !"# !"# !"# !"# !"# !"#
$$$$ $$$$ $$$$ $$$$
!$%$% ! !$%$% ! !$%$% ! !$%$%
""$$&& ""$$&& ""$$&& ""$$&&
"#$%&' !"#$%&' !"#$%&' !"#$%&'
(((((((( ((((((((
! ! !()()()() ! ! ! !()()()()
"" ""((**((** "" ""((**((**
"# !"#()*+()*+ !"# !"#()*+()*+
$$$$((((,,,, $$$$((((,,,,
!$%$%()(),-,- ! !$%$%()(),-,-
""$$&&((**,,.. ""$$&&((**,,..
"#$%&'()*+,-./ !"#$%&'()*+,-./
0000000000000000
! ! ! ! ! ! !0101010101010101
"" "" "" ""0022002200220022
"# !"# !"# !"#0123012301230123
$$$$ $$$$0000444400004444
!$%$% ! !$%$%0101454501014545
""$$&& ""$$&&0022446600224466
"#$%&' !"#$%&'0123456701234567
((((((((0000000088888888
! ! !()()()()0101010189898989
"" ""((**((**0022002288::88::
"# !"#()*+()*+0123012389:;89:;
$$$$((((,,,,000044448888<<<<
!$%$%()(),-,-010145458989<=<=
""$$&&((**,,..0022446688::<<>>
"#$%&'()*+,-./0123456789:;<=>?
```
I actually kind of like how it looks. But if you insist on it being pretty you can dock four chars. Pretty Output:
```
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !
!! !! !! !! !! !! !! !
! ! ! ! ! ! ! !
!! !!!! !!!! !!!! !
! ! ! ! ! ! ! !
!! !! !! !
! ! ! !
!!!!!! !!!!!!!! !
! ! ! ! ! ! ! !
!! !! !! !
! ! ! !
!! !!!! !
! ! ! !
!! !
! !
!!!!!!!!!!!!!! !
! ! ! ! ! ! ! !
!! !! !! !
! ! ! !
!! !!!! !
! ! ! !
!! !
! !
!!!!!! !
! ! ! !
!! !
! !
!! !
! !
!
!
```
Leaving up the older 108 char, cellular automata version.
```
j,d[99][99];main(i){d[0][31]=3;for(;i<64;)d[j+1][i]=putchar(32|d[j][i+2]^d[j][i++]);++j<32&&main(puts(""));}
```
~~So I don't think I'm going to get it much shorter than this so I'll explain the code.~~ I'll leave this explanation up, as some of the tricks could be useful.
```
j,d[99][99]; // these init as 0
main(i){ //starts at 1 (argc)
d[0][48]=3; //seed the automata (3 gives us # instead of !)
for(;i<98;) // print a row
d[j+1][i]=putchar(32|d[j][i+2]]^d[j][i++]);
//relies on undefined behavoir. Works on ubuntu with gcc ix864
//does the automata rule. 32 + (bitwise or can serve as + if you know
//that (a|b)==(a^b)), putchar returns the char it prints
++j<32&&main(puts(""));
// repeat 32 times
// puts("") prints a newline and returns 1, which is nice
}
```
Some output
```
# #
# #
# # # #
# #
# # # #
# # # #
# # # # # # # #
# #
# # # #
# # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# #
# # # #
# # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # #
# # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
```
[Answer]
# PostScript, 120 chars
```
-7 -4 moveto
14 0 rlineto
7{true upath dup
2{120 rotate uappend}repeat[2 0 0 2 7 4]concat}repeat
matrix setmatrix
stroke
```
Ghostscript output:
This is drawing the figure by recursively tripling what's already drawn.
First step is drawing a line. The line is saved as a userpath, then the userpath is added two more times after rotating 120 degrees each time. `[2 0 0 2 7 4]concat` moves the "rotation point" to the center of the next big white "center triangle" that is to be enclosed by replications of the triangle we already have. Here, we're back to step 1 (creating a upath that's tripled by rotation).
The number of iterations is controlled by the first number in line 3.
[Answer]
# J (9 characters)
Easily the ugliest, you really need to squint to see the output ;)
```
2|!/~i.32
```
produces the output
```
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
```
of course you can display it graphically:
```
load 'viewmat'
viewmat 2|!/~i.32
```
[](https://i.stack.imgur.com/Z2pZo.jpg)
[Answer]
# Python (75)
I'm two years late to the party, but I'm surprised that nobody has taken this approach yet
```
from pylab import*
x=[[1,1],[1,0]]
for i in'123':x=kron(x,x)
imsave('a',x)
```
Uses the [Kronecker product](http://en.wikipedia.org/wiki/Kronecker_product) to replace a matrix by multiple copies of itself.
I could save two chars by using `x=kron(x,x);x=kron(x,x)` in line three to get a 16x16 pixel image with three visible levels or add another char to the iterator and end up with a 2^16 x 2^16 = 4.3 Gigapixel image and 15 triangle levels.
[Answer]
# APL, ~~37~~ 32 (~~28~~ 23)
### Upright triangle (~~37~~ 32-char)
```
({((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 2⍴'/\'
```
**Explanation**
* `1 2⍴'/\'`: Create a 1×2 character matrix `/\`
* `{((-1⌷⍴⍵)⌽⍵,∊⍵)⍪⍵,⍵}`: A function that pad the right argument on both sides with blanks to create a matrix double as wide, then laminates the right argument itself doubled onto the bottom.
E.g. `/\` would become
```
/\
/\/\
```
* `⍣⎕`: Recur the function (user input) times.
**Example output**
```
/\
/\/\
/\ /\
/\/\/\/\
/\ /\
/\/\ /\/\
/\ /\ /\ /\
/\/\/\/\/\/\/\/\
/\ /\
/\/\ /\/\
/\ /\ /\ /\
/\/\/\/\ /\/\/\/\
/\ /\ /\ /\
/\/\ /\/\ /\/\ /\/\
/\ /\ /\ /\ /\ /\ /\ /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
```
### Skewed Triangle (~~28~~ 23-char)
```
({(⍵,∊⍵)⍪⍵,⍵}⍣⎕)1 1⍴'○'
```
**Explaination**
* `1 1⍴'○'`: Create a 1×1 character matrix `○`
* `{(⍵,∊⍵)⍪⍵,⍵}`: A function that pad the right argument on the right with blanks to create a matrix double as wide, then laminates the right argument itself doubled onto the bottom.
E.g. `○` would become
```
○
○○
```
* `⍣⎕`: Recur the function (user input) times.
**Example output**
```
○
○○
○ ○
○○○○
○ ○
○○ ○○
○ ○ ○ ○
○○○○○○○○
○ ○
○○ ○○
○ ○ ○ ○
○○○○ ○○○○
○ ○ ○ ○
○○ ○○ ○○ ○○
○ ○ ○ ○ ○ ○ ○ ○
○○○○○○○○○○○○○○○○
```
[Answer]
**matlab 56**
```
v=[1;-1;j];plot(filter(1,[1,-.5],v(randi(3,1,1e4))),'.')
```
[Answer]
**Logo, 75 characters**
59 characters for just the first function, the second one calls the first with the size and the depth/number of iterations. So you could just call the first function from the interpreter with the command: e 99 5, or whatever size you want to output
```
to e :s :l
if :l>0[repeat 3[e :s/2 :l-1 fd :s rt 120]]
end
to f
e 99 5
end
```
[Answer]
# J (18 characters)
```
' *'{~(,,.~)^:9 ,1
```
## Result
```
*
**
* *
****
* *
** **
* * * *
********
* *
** **
* * * *
**** ****
* * * *
** ** ** **
* * * * * * * *
****************
* *
** **
* * * *
**** ****
* * * *
** ** ** **
* * * * * * * *
******** ********
* * * *
** ** ** **
* * * * * * * *
**** **** **** ****
* * * * * * * *
** ** ** ** ** ** ** **
* * * * * * * * * * * * * * * *
********************************
```
[Answer]
# Python (90 chars)
```
from turtle import*
def l():left(60)
def r():right(60)
def f():forward(1)
def L(n):
if n:n-=1;R(n);l();L(n);l();R(n)
else:f()
def R(n):
if n:n-=1;L(n);r();R(n);r();L(n)
else:f()
l();L(8)
```
[**Try it online**](https://trinket.io/python/8acda70c9b)
Draw fractal line filling Sierpinsky Triangle
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 12 bytes
```
×.≥∘⍉⍨↑,⍳⎕⍴2
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob2pm/qO2CQZcjzra0/4fnq73qHPpo44Zj3o7H/WueNQ2UedR72agoke9W4z@A5X8T@MyBQA "APL (Dyalog Classic) – Try It Online")
[Answer]
# Asymptote, 152 bytes
I'll add this, mostly since I've seen more or less no answers in asymptote on this site. A few wasted bytes for nice formatting and generality, but I can live with that. Changing A,B and C will change where the corners of the containing triangle are, but probably not in the way you think. Increase the number in the inequality to increase the depth.
```
pair A=(0,0),B=(1,0),C=(.5,1);void f(pair p,int d){if(++d<7){p*=2;f(p+A*2,d);f(p+B*2,d);f(p+C*2,d);}else{fill(shift(p/2)*(A--B--C--cycle));}}f((0,0),0);
```
or ungolfed and readable
```
pair A=(0,0), B=(1,0), C=(.5,1);
void f(pair p, int d) {
if (++d<7) {
p *= 2;
f(p+A*2,d);
f(p+B*2,d);
f(p+C*2,d);
} else {
fill(shift(p/2)*(A--B--C--cycle));
}
}
f((0,0),0);
```
So asymptote is a neat vector graphics language with somewhat C-like syntax. Quite useful for somewhat technical diagrams. Output is of course in a vector format by default (eps, pdf, svg) but can be converted into basically everything imagemagick supports. Output:
[](https://i.stack.imgur.com/1XyYE.png)
[Answer]
# [Mathematica](https://www.wolfram.com/mathematica/), 29 bytes
```
Image@Array[BitAnd,{2,2}^9,0]
```
![Image@Array[BitAnd,{2,2}^9,0]](https://i.stack.imgur.com/7IR6g.jpg)
The Sierpinski tetrahedron can be drawn in a similar way:
```
Image3D[1-Array[BitXor,{2,2,2}^7,0]]
```
![Image3D[1-Array[BitXor,{2,2,2}^7,0]]](https://i.stack.imgur.com/TUzsq.jpg)
[Answer]
# [J](http://jsoftware.com/), ~~37~~ 35 bytes
*-2 bytes thanks to FrownyFrog*
```
(,.~,~' '&,.^:#)@[&0' /\',:'/__\'"_
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NXT06nTq1BXU1XT04qyUNR2i1QzUFfRj1HWs1PXj42PUleL/a3Il2uoZKZiogCQUQKIK6lx@TnoKqckZ@QqJXGAqTcFQAcJSV4eJGKELGKMLmHBx/QcA "J – Try It Online")
This is Peter Taylor's ascii art version converted to J. Could save bytes with a less pretty version, but why?
```
/\
/__\
/\ /\
/__\/__\
/\ /\
/__\ /__\
/\ /\ /\ /\
/__\/__\/__\/__\
```
[Answer]
# [Lua](http://golly.sourceforge.net/Help/lua.html) script in [Golly](http://golly.sourceforge.net/), 54 bytes
```
g=golly()
g.setrule("W60")
g.setcell(0,0,1)
g.run(512)
```
Golly is a cellular automata simulator with Lua and Python scripting support.
This script sets the rule to Wolfram Rule 60, sets the cell at (0,0) to 1, and runs 512 steps.
[](https://i.stack.imgur.com/kTOs5.png)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes
```
1=IGx^Db,
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f0NbTvSLOJUnn/39jIwA "05AB1E – Try It Online")
The number of rows is equal to the input.
# Explanation:
```
1=IGx^Db,
1= print "1" and push 1
IG for N in range(1, I): (where I is the input)
x push last element on stack multiplied by 2
^ pop last two elements, push their bitwise xor (output is in decimal)
D duplicate last element of stack
b, replace last element of stack with its binary representation, then print/pop
```
This takes advantage of the fact that a(n+1) = a(n) XOR 2\*a(n), which I found on [this relevant OEIS page](https://oeis.org/A001317)
[Answer]
**Mathematica 63**
```
ListPlot@ReIm@NestList[#/2+RandomChoice[{0,1,-1}^(1/3)]&,0.,8!]
```
[](https://i.stack.imgur.com/zF0bb.png)
**Mathematica 67**
```
Region@Polygon@ReIm@Nest[Tr/@Tuples[{p,#}/2]&,{p={0,1,-1}^(1/3)},6]
```
[](https://i.stack.imgur.com/WbSgv.png)
[Answer]
# 8086 Machine code - 18 bytes (unknown author) / 27 bytes (mine)
In early 1990s, I organized a small competition on programmer's board on a Croatian BBS, who can write the smallest program to draw the Sierpinski triangle.
My best solution was 27 bytes long, but there were several even smaller and unique solutions, with smallest one being only 18 bytes of machine code. Unfortunately, I forgot the name of the person who wrote it - so if the original author is reading this, please contact me. :)
---
**18 bytes solution by an unknown Croatian programmer**:
```
Bytes: B0 13 CD 10 B5 A0 8E D9 30 84 3F 01 AC 32 04 E2 F7 C3
0100 B013 MOV AL,13
0102 CD10 INT 10
0104 B5A0 MOV CH,A0
0106 8ED9 MOV DS,CX
0108 30843F01 XOR [SI+013F],AL
010C AC LODSB
010D 3204 XOR AL,[SI]
010F E2F7 LOOP 0108
0111 C3 RET
```
Which draws this:
[](https://i.stack.imgur.com/xH4s2.png)
---
**My 27 bytes solution**:
```
Bytes: B0 13 CD 10 B7 A0 8E C3 8E DB BF A0 00 AA B9 C0 9E BE 61 FF AC 32 04 AA E2 FA C3
0100 B013 MOV AL,13
0102 CD10 INT 10
0104 B7A0 MOV BH,A0
0106 8EC3 MOV ES,BX
0108 8EDB MOV DS,BX
010A BFA000 MOV DI,00A0
010D AA STOSB
010E B9C09E MOV CX,9EC0
0111 BE61FF MOV SI,FF61
0114 AC LODSB
0115 3204 XOR AL,[SI]
0117 AA STOSB
0118 E2FA LOOP 0114
011A C3 RET
```
Which draws this:
[](https://i.stack.imgur.com/UXaO2.png)
[Answer]
## C, 106 chars
```
i,j;main(){for(;i<32;j>i/2?puts(""),j=!++i:0)
printf("%*s",j++?4:33-i+i%2*2,i/2&j^j?"":i%2?"/__\\":"/\\");}
```
(It still amuses me that `puts("")` is the shortest way to output a newline in C.)
Note that you can create larger (or smaller) gaskets by replacing the `32` in the `for` loop's test with a larger (smaller) power of two, as long as you also replace the `33` in the middle of the `printf()` with the power-of-two-plus-one.
] |
[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/99500/edit).
Closed 7 years ago.
[Improve this question](/posts/99500/edit)
### Challenge:
Write a lossless encoder/decoder that is able to compress its own source code.
### Usage:
`progname` **`encode`**
Encodes data provided on the standard input, writes the encoded representation of the data to the standard output.
`progname` **`decode`**
Decodes data produced by `progname` **`encode`**. Reads the encoded data from the standard input, writes the decoded data to standard output. Must perfectly restore the original data.
### Example:
```
$ progname encode < /usr/include/stdlib.h > encoded
$ progname decode < encoded > decoded
$ diff -qs /usr/include/stdlib.h decoded
Files /usr/include/stdlib.h and decoded are identical
```
### Requirements:
1. It must be a real lossless encoder/decoder for *all* inputs - encoding any data and then decoding it must produce the original data.
2. If the input is identical to the program's source code, the size of encoded output must be less than the size of the input.
### Score:
Size of the program's source code + the size of its encoded source code
### Clarification:
The program doesn't need to be a general purpose compressor/decompressor. That's why its commands are called encode/decode. It may also use existing tools predating this question.
]
|
[Question]
[
A [Flow Snake, also known as a Gosper curve](https://en.wikipedia.org/wiki/Gosper_curve), is a fractal curve, growing exponentially in size with each order/iteration of a simple process. Below are the details about the construction and a few examples for various orders:
*Order 1 Flow Snake*:
```
____
\__ \
__/
```
*Order 2 Flow Snake*:
```
____
____ \__ \
\__ \__/ / __
__/ ____ \ \ \
/ __ \__ \ \/
\ \ \__/ / __
\/ ____ \/ /
\__ \__/
__/
```
*Order 3 Flow Snake*:
```
____
____ \__ \
\__ \__/ / __
__/ ____ \ \ \ ____
/ __ \__ \ \/ / __ \__ \
____ \ \ \__/ / __ \/ / __/ / __
____ \__ \ \/ ____ \/ / __/ / __ \ \ \
\__ \__/ / __ \__ \__/ / __ \ \ \ \/
__/ ____ \ \ \__/ ____ \ \ \ \/ / __
/ __ \__ \ \/ ____ \__ \ \/ / __ \/ /
\ \ \__/ / __ \__ \__/ / __ \ \ \__/
\/ ____ \/ / __/ ____ \ \ \ \/ ____
\__ \__/ / __ \__ \ \/ / __ \__ \
__/ ____ \ \ \__/ / __ \/ / __/ / __
/ __ \__ \ \/ ____ \/ / __/ / __ \/ /
\/ / __/ / __ \__ \__/ / __ \/ / __/
__/ / __ \ \ \__/ ____ \ \ \__/ / __
/ __ \ \ \ \/ ____ \__ \ \/ ____ \/ /
\ \ \ \/ / __ \__ \__/ / __ \__ \__/
\/ / __ \/ / __/ ____ \ \ \__/
\ \ \__/ / __ \__ \ \/
\/ \ \ \__/ / __
\/ ____ \/ /
\__ \__/
__/
```
# Construction
Consider the order 1 Flow Snake to be built of a path containing 7 edges and 8 vertices (labelled below. Enlarged for feasibility):
```
4____5____6
\ \
3\____2 7\
/
0____1/
```
Now for each next order, you simply replace the edges with a rotated version of this original order 1 pattern. Use the following 3 rules for replacing the edges:
**1** For a horizontal edge, replace it with the original shape as is:
```
________
\ \
\____ \
/
____/
```
**2** For a `/` edge (`12` in the above construction), replace it with the following rotated version:
```
/
/ ____
\ / /
\/ /
/
____/
```
**3** For a `\` edge (`34`and `67` above), replace it with the following rotated version:
```
/
/ ____
\ \ \
\ \ \
\ /
\/
```
So for example, order 2 with vertices from order 1 labelled will look like
```
________
\ \
________ \____ \6
\ \ / /
\____ \5___/ / ____
/ \ \ \
4___/ ________ \ \ \7
/ \ \ \ /
/ ____ \____ \2 \/
\ \ \ / /
\ \ \3___/ / ____
\ / \ / /
\/ ________ \/ /
\ \ /
\____ \1___/
/
0___/
```
Now for any higher order, you simply break up the current level into edges of lengths 1 `/`, 1 `\` or 2 `_` and repeat the process. Do note that even after replacing, the common vertices between any two consecutive edges are still coinciding.
# Challenge
* You have to write a function of a full program that receives a single integer `N` via STDIN/ARGV/function argument or the closest equivalent and prints the order `N` Flow Snake on STDOUT.
* The input integer is always greater than `0`.
* There should not be any leading spaces which are not part of the pattern.
* There should be either no trailing spaces or enough trailing spaces to pad the pattern to fill the minimum bounding rectangle completely.
* Trailing newline is optional.
# Fun Facts
* Flow Snakes is a word play of Snow Flakes, which this pattern resembles for order 2 and above
* The Flow and Snakes actually play a part in the pattern as the pattern is made up of a single path flowing throughout.
* If you notice carefully, the order 2 (and higher as well) pattern comprises of rotations of order 1 pattern pivoted on the common vertex of the current and the previous edge.
* There is a Non ASCII variant of Flow Snakes which can be found [here](http://80386.nl/projects/flowsnake/) and at several other locations.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code in bytes win!
---
# Leaderboard
**[The first post of the series generates a leaderboard.](https://codegolf.stackexchange.com/q/50484/31414)**
To make sure that your answers show up, please start every answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
[Answer]
# Python 2, ~~428~~ ~~411~~ 388 bytes
This one was pretty tricky. The patterns don't retain their ratios after each step meaning its very difficult to procedurally produce an image from its predecessor. What this code does, though its pretty unreadable after some intense math golfing, is actually draw the line from start to finish using the recursively defined `D` function.
The size was also an issue, and I ended up just starting in the middle of a `5*3**n` sided square and cropping things afterward, though if I can think of better way to calculate the size I might change it.
```
n=input();s=5*3**n
r=[s*[" "]for i in[0]*s]
def D(n,x,y,t=0):
if n<1:
x-=t%2<1;y+=t%3>1;r[y][x]='_/\\'[t/2]
if t<2:r[y][x+2*t-1]='_'
return[-1,2,0,1,0,1][t]+x,y-(2<t<5)
for c in[int(i)^t%2for i in"424050035512124224003"[t/2::3]][::(t^1)-t]:x,y=D(n-1,x,y,c)
return x,y
D(n,s/2,s/2)
S=[''.join(c).rstrip()for c in r]
for l in[c[min(c.find('\\')%s for c in S):]for c in S if c]:print l
```
[Answer]
# JavaScript (*ES6*), 356 ~~362 370~~
That's a difficult one ...
Each shape is stored as a path. There are 6 basic building blocks (3 + 3 backward)
* `0` diagonal up left to bottom right (`4` backward)
* `1` diagonal bottom left to up right (`5` backward)
* `2` horizontal left to right (`6` backward)
For each one, there is a replacing step to be applied when increasing order:
* `0` --> `0645001` (backward `4` --> `5441024`)
* `1` --> `2116501` (backward `5` --> `5412556`)
* `2` --> `2160224` (backward `6` --> `0664256`)
values prefilled in the`h` array, even if the elements 4..6 can be obtained from 0..2 using
```
;[...h[n]].reverse().map(x=>x^4).join('')
```
To obtain the shape for the given order, the path is built in the p variable applying the substitutions repeatedly. Then the main loop iterates on the p variable and draw the shape inside the g[] array, where each element is a row.
Starting at position (0,0), each index can become negative (y index at high orders). I avoid negative y indexes shifting all the g array whenever I find a negative y value. I don't care if the x index becomes negative, as in JS negative indexes are allowed, just a little more difficult to manage.
In the last step, I scan the main array using .map, but for each row I need to use an explicit for(;;) loop using the `b` variable that holds the least x index reached (that will be < 0).
In the `console.log` version there is a handy leading newline, that can be easily made a trailing newline swapping 2 rows, as in the snippet version.
```
f=o=>{
g=[],x=y=b=0,
h='064500192116501921602249954410249541255690664256'.split(9);
for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
for(t of p)
z='\\/_'[s=t&3],
d=s-(s<1),
t>3&&(x-=d,y+=s<2),
y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
t<3&&(x+=d,y-=s<2),
x<b?b=x:0;
g.map(r=>
{
o+='\n';
for(x=b;x<r.length;)o+=r[x++]||' '
},o='');
console.log(o)
}
```
Handy snippet to test (in Firefox) :
```
f=o=>{
g=[],x=y=b=0,
h='064500192116501921602249954410249541255690664256'.split(9);
for(p=h[2];--o;)p=p.replace(/./g,c=>h[c]);
for(t of p)
z='\\/_'[s=t&3],
d=s-(s<1),
t>3&&(x-=d,y+=s<2),
y<0&&(y++,g=[,...g]),r=g[y]=g[y]||[],
s?s>1?r[x]=r[x+1]=z:r[x]=z:r[x-1]=z,
t<3&&(x+=d,y-=s<2),
x<b?b=x:0;
g.map(r=>
{
for(x=b;x<r.length;)o+=r[x++]||' ';
o+='\n'
},o='');
return o
}
// TEST
fs=9;
O.style.fontSize=fs+'px'
function zoom(d) {
d += fs;
if (d > 1 && d < 40)
fs=d, O.style.fontSize=d+'px'
}
```
```
#O {
font-size: 9px;
line-height: 1em;
}
```
```
<input id=I value=3><button onclick='O.innerHTML=f(I.value)'>-></button>
<button onclick="zoom(2)">Zoom +</button><button onclick="zoom(-2)">Zoom -</button>
<br>
<pre id=O></pre>
```
[Answer]
# Haskell, 265 bytes
```
(?)=div
(%)=mod
t[a,b]=[3*a+b,2*b-a]
_#[0,0]=0
0#_=3
n#p=[352,6497,2466,-1]!!((n-1)#t[(s+3)?7|s<-p])?(4^p!!0%7)%4
0&_=0
n&p=(n-1)&t p+maximum(abs<$>sum p:p)
n!b=n&[1,-b]
f n=putStr$unlines[["__ \\/ "!!(2*n#t[a?2,-b]+a%2)|a<-[b-n!2+1..b+n!2+0^n?3]]|b<-[-n!0..n!0]]
```
(Note: on GHC before 7.10, you will need to add `import Control.Applicative` or replace `abs<$>` with `map abs$`.)
[Run online at Ideone.com](http://ideone.com/mx5CR1)
`f n :: Int -> IO ()` draws the level `n` flowsnake. The drawing is computed in bitmap order rather than along the curve, which allows the algorithm to run in O(n) space (that is, logarithmic in the drawing size). Nearly half of my bytes are spent computing which rectangle to draw!
[Answer]
# Perl, ~~334 316~~ 309
```
$_=2;eval's/./(map{($_,"\1"x7^reverse)}2003140,2034225,4351440)[$&]/ge;'x($s=<>);
s/2|3/$&$&/g;$x=$y=3**$s-1;s!.!'$r{'.qw($y--,$x++ ++$y,--$x $y,$x++ $y,--$x
$y--,--$x ++$y,$x++)[$&]."}=$&+1"!eeg;y!1-6!//__\\!,s/^$x//,s/ *$/
/,print for
grep{/^ */;$x&=$&;$'}map{/^/;$x=join'',map$r{$',$_}||$",@f}@f=0..3**$s*2
```
Parameter taken on the standard input.
Test [me](http://ideone.com/iB5taR).
[Answer]
# Haskell, ~~469~~ ~~419~~ ~~390~~ ~~385~~ 365 bytes
the function f::Int->IO() takes an integer as input and print the flow snake
```
e 0=[0,0];e 5=[5,5];e x=[x]
f n=putStr.t$e=<<g n[0]
k=map$(53-).fromEnum
g 0=id
g n=g(n-1).(=<<)(k.(words"5402553 5440124 1334253 2031224 1345110 2003510"!!))
x=s$k"444666555666"
y=s$k"564645554545"
r l=[minimum l..maximum l]
s _[]=[];s w(x:y)=w!!(x+6):map(+w!!x)(s w y)
t w=unlines[["_/\\\\/_ "!!(last$6:[z|(c,d,z)<-zip3(x w)(y w)w,c==i&&d==j])|i<-r.x$w]|j<-r.y$w]
```
[Answer]
# CJam, 144 bytes
```
0_]0a{{_[0X3Y0_5]f+W@#%~}%}ri*{_[YXW0WW]3/If=WI6%2>#f*.+}fI]2ew{$_0=\1f=~-
"__1a /L \2,"S/=(@\+\~.+}%_2f<_:.e>\:.e<:M.-:)~S*a*\{M.-~3$3$=\tt}/zN*
```
Newline added to avoid scrolling. [Try it online](http://cjam.aditsu.net/#code=0_%5D0a%7B%7B_%5B0X3Y0_5%5Df%2BW%40%23%25~%7D%25%7Dri*%7B_%5BYXW0WW%5D3%2FIf%3DWI6%252%3E%23f*.%2B%7DfI%5D2ew%7B%24_0%3D%5C1f%3D~-%22__1a%20%2FL%20%5C2%2C%22S%2F%3D(%40%5C%2B%5C~.%2B%7D%25_2f%3C_%3A.e%3E%5C%3A.e%3C%3AM.-%3A)~S*a*%5C%7BM.-~3%243%24%3D%5Ctt%7D%2FzN*&input=3)
The program works in several steps:
1. The initial fractal (order 1) is encoded as a sequence of 7 angles (conceptually, multiples of 60°) representing the direction of movement
2. The fractal is "applied" to a horizontal segment (order 0 fractal) N times to generate all the "movements" in the order N fractal
3. Starting from [0 0], the movements are translated into a sequence of points with [x y] coordinates
4. Each segment (pair of points) is converted to 1 or 2 [x y c] triplets, representing the character c at coordinates x, y
5. The bounding rectangle is determined, the coordinates are adjusted and a matrix of spaces is generated
6. For each triplet, the character c is placed at position x, y in the matrix, and the final matrix is adjusted for output
[Answer]
# C, ~~479~~ ~~474~~ ~~468~~ 427 bytes
There's no beating the Perl and Haskell guys I guess, but since there's no C submission here yet:
```
#define C char
C *q="053400121154012150223433102343124450553245";X,Y,K,L,M,N,i,c,x,y,o;F(C*p,
int l,C d){if(d){l*=7;C s[l];for(i=0;i<l;i++)s[i]=q[(p[i/7]%8)*7+i%7];return F
(s,l,d-1);}x=0;y=0;o=32;while(l--){c=*p++%8;for(i=!(c%3)+1;i--;) {K=x<K?x:K;L=
y<L?y:L;M=x>M?x:M;N=y>N?y:N;y+=c&&c<3;x-=c%5>1;if(x==X&y==Y)o="_\\/"[c%3];y-=c
>3;x+=c%5<2;}}return X<M?o:10;}main(l){F(q,7,l);for(Y=L;Y<N;Y++)for(X=K;X<=M;X
++)putchar(F(q,7,l));}
```
To save space on a atoi() call, the *number* of arguments passed to the program is used for the level.
The program runs in O(n^3) or worse; first the path is calculated once to find the min/max coordinates, then for each (x,y) pair it is calculated once to find the character on that specific location. Terribly slow, but saves on memory administration.
Example run at <http://codepad.org/ZGc648Xi>
[Answer]
# Python 2, ~~523~~ ~~502~~ ~~475~~ ~~473~~ ~~467~~ ~~450~~ 437 bytes
```
l=[0]
for _ in l*input():l=sum([map(int,'004545112323312312531204045045050445212331'[t::6])for t in l],[])
p=[]
x=y=q=w=Q=W=0
for t in l:T=t|4==5;c=t in{2,4};C=t<3;q=min(q,x);Q=max(Q,x+C);w=min(w,y);W=max(W,y);a=C*2-1;a*=2-(t%3!=0);b=(1-T&c,-1)[T&1-c];x+=(a,0)[C];y+=(0,b)[c];p+=[(x,y)];x+=(0,a)[C];y+=(b,0)[c]
s=[[' ']*(Q-q)for _ in[0]*(W-w+1)]
for t,(x,y)in zip(l,p):x-=q;s[y-w][x:x+1+(t%3<1)]='_/\_'[t%3::3]
for S in s:print''.join(S)
```
Pffft, costed me a like 3 hours, but was fun to do!
The idea is to split the task in multiple steps:
1. Calculate all the edges (encoded as 0-5) in order of appearence (so from the beginning of the snake to the end)
2. Calculate the position for each of the edges (and save the min and max values for x and y)
3. Build the strings it consists of (and use the min values to offset, so that we don't get negative indices)
4. Print the strings
Here is the code in ungolfed form:
```
# The input
n = int(input())
# The idea:
# Use a series of types (_, /, \, %), and positions (x, y)
# Forwards: 0: __ 1: / 2: \
# Backwards: 3: __ 4: / 5: \
# The parts
pieces = [
"0135002",
"0113451",
"4221502",
"5332043",
"4210443",
"5324551"
]
# The final types list
types = [0]
for _ in range(n):
old = types
types = []
for t in old:
types.extend(map(int,pieces[t]))
# Calculate the list of positions (and store the mins and max')
pos = []
top = False
x = 0
y = 0
minX = 0
minY = 0
maxX = 0
maxY = 0
for t in types:
# Calculate dx
dx = 1 if t < 3 else -1
if t%3==0:
dx *= 2 # If it's an underscore, double the horizontal size
# Calculate dy
top = t in {1, 5}
dy = 0
if top and t in {0, 3, 1, 5}:
dy = -1
if not top and t in {2, 4}:
dy = 1
# If backwards, add dx before adding the position to the list
if t>2:
x += dx
# If top to bottom, add dy before adding the position to the list
if t in {2,4}:
y += dy
# Add the current position to the list
pos += [(x, y)]
# In the normal cases (going forward and up) modify the x and y after changing the position
if t<3:
x += dx
if t not in {2, 4}:
y += dy
# Store the max and min vars
minX = min(minX, x)
maxX = max(maxX, x + (t<3)) # For forward chars, add one to the length (we never end with __'s)
minY = min(minY, y)
maxY = max(maxY, y)
# Create the string (a grid of charachters)
s = [[' '] * (maxX - minX) for _ in range(maxY - minY + 1)]
for k, (x, y) in enumerate(pos):
x -= minX
y -= minY
t = types[k]
char = '/'
if t % 3 == 0:
char = '__'
if t % 3 == 2:
char = '\\'
s[y][x : x + len(char)] = char
# Print the string
for printString in s:
print("".join(printString))
```
**Edit:** I changed the language to python 2, to be compatible with [my answer for #3](https://codegolf.stackexchange.com/a/50652/40620) (and it also saves 6 more bytes)
[Answer]
# Pari/GP, 395
Looping over x,y character positions and calculating what char to print. Moderate attempts at minimizing, scored with whitespace and comments stripped.
```
k=3;
{
S = quadgen(-12); \\ sqrt(-3)
w = (1 + S)/2; \\ sixth root of unity
b = 2 + w; \\ base
\\ base b low digit position under 2*Re+4*Im mod 7 index
P = [0, w^2, 1, w, w^4, w^3, w^5];
\\ rotation state table
T = 7*[0,0,1,0,0,1,2, 1,2,1,0,1,1,2, 2,2,2,0,0,1,2];
C = ["_","_", " ","\\", "/"," "];
\\ extents
X = 2*sum(i=0,k-1, vecmax(real(b^i*P)));
Y = 2*sum(i=0,k-1, vecmax(imag(b^i*P)));
for(y = -Y, Y,
for(x = -X+!!k, X+(k<3), \\ adjusted when endpoint is X limit
z = (x- (o = (x+y)%2) - y*S)/2;
v = vector(k,i,
z = (z - P[ d = (2*real(z) + 4*imag(z)) % 7 + 1 ])/b;
d);
print1( C[if(z,3,
r = 0;
forstep(i=#v,1, -1, r = T[r+v[i]];);
r%5 + o + 1)]) ); \\ r=0,7,14 mod 5 is 0,2,4
print())
}
```
Each char is the first or second of a hexagon cell. A cell location is a complex number z split into base b=2+w with digits 0, 1, w^2, ..., w^5, where w=e^(2pi/6) sixth root of unity. Those digits are kept just as a distinguishing 1 to 7 then taken high to low through a state table for net rotation. This is in the style of [flowsnake code by Ed Shouten](http://80386.nl/projects/flowsnake/) (`xytoi`) but only for net rotation, not making digits into an "N" index along the path. The extents are relative to an origin 0 at the centre of the shape. As long as the limit is not an endpoint these are the middle of a 2-character hexagon and only 1 of those chars is needed. But when the snake start and/or end are the X limit 2 chars are needed, which is k=0 start and k<3 end. Pari has "quads" like sqrt(-3) builtin but the same can be done with real and imaginary parts separately.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 7 years ago.
[Improve this question](/posts/94904/edit)
I was challenged by one of my friends to solve this coding problem:
Given a non-negative number represented as an array of digits, add one to the number. The digits are stored such that the most significant digit is at the head of the list. Return the value as a new list.
This was my solution, which does not work if [9,8,7,6,5,4,3,2,1,0] is input.
```
public int[] plusOne(int[] digits) {
int[] ret;
int integervalue;
integervalue = 0;
String stringvalue;
for(int i = 0; i < digits.length; i++){
integervalue = integervalue*10 + digits[i];
}
integervalue++;
stringvalue = String.valueOf(integervalue);
ret = new int[stringvalue.length()];
for(int i = 0; i < stringvalue.length(); i++) {
ret[i] = stringvalue.charAt(i) - 48;
}
return ret;
}
```
My apologies if my code is confusing, awkward, hard-to-read, or if the solution is incredibly obvious. I am still a rookie in Java.
]
|
[Question]
[
## Challenge
Given an input `n`, print an ASCII art cake `n` layers tall, viewed from the side, with two candles on top. Refer to the examples below for details.
## Output
```
>> cake(1)
_|_|_
| |
+-----+
>> cake(3)
_|_|_
| |
+---------+
| |
+-------------+
| |
+-------------+
```
...and so on.
## Rules
* Standard loopholes prohibited
* Please make an attempt at a clever solution
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins. However, the answer will not be selected.
## Have fun!
[Answer]
# Python 2, 238 chars
```
i=input()
m=["+"+"-"*(i*4+1)+"+","|"+" "*(i*4+1)+"|"]
for v in range(i,1,-1):
m+=[" "*(i-v)*2+"+"+"-"*(v*4+1)+"+"," "*(i-v+1)*2+"|"+" "*((v-1)*4+1)+"|"]
m.pop()
m+=[" "*(i-1)*2+"|"+" "*5+"|"," "*(i-1)*2+" _|_|_"]
print'\n'.join(m[::-1])
```
The missing example of Cake 2:
```
_|_|_
| |
+---------+
| |
+---------+
```
[Answer]
# Ruby, 109 107 bytes
```
->n{p=->t{puts t.center 3+4*n}
p['_|_|_']
(1..n).map{|i|p[?|+' '*(1+4*i)+?|]
p[?++?-*((i<n ?5:1)+4*i)+?+]}}
```
[Answer]
## JavaScript (ES6), 134 bytes
A recursive cake.
```
f=(n,i=--n,r=(n,c)=>'- '[+!c].repeat(n),p=r((i-n)*2),j=n*4+5,x=p+`+${r(j,1)}+
`)=>(n?f(n-1,i)+x:p+` _|_|_
`)+p+`|${r(j)}|
`+(n-i?'':x)
```
### Demo
```
let f=(n,i=--n,r=(n,c)=>'- '[+!c].repeat(n),p=r((i-n)*2),j=n*4+5,x=p+`+${r(j,1)}+
`)=>(n?f(n-1,i)+x:p+` _|_|_
`)+p+`|${r(j)}|
`+(n-i?'':x)
console.log(f(4))
```
[Answer]
## Batch, 233 bytes
```
@echo off
set i=
for /l %%j in (2,1,%1)do call set i= %%i%%
echo %i% _^|_^|_
set s=-----
for /l %%j in (2,1,%1)do call:l
echo ^|%s:-= %^|
echo +%s%+
exit/b
:l
echo %i%^|%s:-= %^|
set i=%i:~2%
set s=----%s%
echo %i%+%s%+
```
Shorter than Python? Something must be wrong...
[Answer]
# Haskell, 103 bytes
```
f(a:b)n=a:([0..4*n]>>b)++[a]
x!n=x:[f"| "n,f"+-"n]
g 1=" _|_|_"!1
g n=map(" "++)(init.g$n-1)++f"+-"n!n
```
Defines a function `g` which returns a list of strings containing the lines of the output
[Answer]
# 05AB1E, ~~115~~, 101 chars
```
>UXð×?" _|_|_",Xð×?"| |",X<U0<VXGNVXY-ð×?'+?8Y·+G'-?}'+,XY-ð×?'|?7Y·+ð×?'|,}XY-ð×?'+?8Y·+G'-?}'+,
```
Saved 14 chars thanks to Adnan!
Definitely some room for golfing here.
[Try it online!](http://05ab1e.tryitonline.net/#code=PlVYw7DDlz8iIF98X3xfIixYw7DDlz8ifCAgICAgfCIsWDxVMDxWWEdOVlhZLcOww5c_Jys_OFnCtytHJy0_fScrLFhZLcOww5c_J3w_N1nCtyvDsMOXPyd8LH1YWS3DsMOXPycrPzhZwrcrRyctP30nKyw&input=MQ)
Note that this does print everything offset by one space.
[Answer]
# Python 2, 122 bytes
```
a=' '*input()
b='+-+'
c=d=' '
while a:b='+----'+b[1:];c=d*4+c;a=a[2:];print a+[' _|_|_',b][c>d*5]+'\n%s|%%s|'%a%c
print b
```
[Answer]
# Python 3, 162 characters
```
p=print
t=int(input())
d=4*'-'
s=' '
a='+\n'
r=(t-1)*s
p(r+' _|_|_\n'+r+'| |')
for i in range(2,t+1):b=(t-i)*s;p(b+'+-'+i*d+a+b+'| '+i*2*s+'|')
p('+-'+t*d+a)
```
It's not very clever, but I've never done one of these before. (Edit: removed unnecessary parentheses; reduced by one more character)
[Answer]
# Pyth, 73 bytes
```
+K*dtyQ"_|_|_"+tK"| |"jP.iJms[*\ yt-Qd\+*+5*4d\-\+)+StQtQmXd"+-""| "J
```
A program that takes input of an integer on STDIN and prints the result.
There is probably still some golfing to be done here.
[Try it online](https://pyth.herokuapp.com/?code=%2BK%2adtyQ%22_%7C_%7C_%22%2BtK%22%7C+++++%7C%22jP.iJms%5B%2a%5C+yt-Qd%5C%2B%2a%2B5%2a4d%5C-%5C%2B%29%2BStQtQmXd%22%2B-%22%22%7C+%22J&test_suite=1&test_suite_input=1%0A2%0A3%0A4%0A5&debug=0)
*Explanation coming later*
[Answer]
# JavaScript (ES6), 171 bytes
```
n=>[(s=" "[R='repeat'](n-1))+" _|_|_",s+"| |",...Array(n-1),`+${"-"[R](n*4+1)}+`].map((_,i)=>_||(s=" "[R](n-i))+`+${"-"[R](i=i*4+1)}+`+`
${s}|${" "[R](i)}|`).join`
`
```
First pass, probably not optimal...
[Answer]
# PHP, ~~150~~ ~~147~~ ~~138~~ ~~136~~ ~~130~~ 140 bytes
new approach:
```
echo$p=str_pad("",-2+2*$n=$argv[1])," _|_|_";for($x=" ",$b=$y="----";$n--;){$a.=$x;if($n)$b.=$y;echo"
$p| $a|
",$p=substr($p,2),"+-$b+";}
```
old version for reference:
```
$p=str_pad;for($o=["_|_|_"];$i++<$n=$argv[1];$o[]="+".$p("",($i<$n)*4+$e,"-")."+")$o[]="|".$p("",$e=$i*4+1)."|";foreach($o as$s)echo$p($s,$n*4+3," ",2),"
";
```
[Answer]
# Vimscript, ~~116~~ 115 bytes
Pretty messy but it works!
```
fu A(n)
let @z="Vkyjply4lpjy4hp"
exe "norm 2i+\e5i-\eo||\e5i \e".a:n."@zddl4xggd$i_|_|_"
exe "%ce ".(a:n*4+3)
endfu
```
To call it: `call A(3)` in an *empty* buffer. To load the function, `source cake.vim`
## Explanation
* `2i+<Esc>5i-<Esc>` writes the first line `+-----+`
* `o||<Esc>5i<Space><Esc>` adds `| |` on the second line
* `Vkyjply4lpjy4hp` is saved in the macro `@z` - it visually selects both lines, yanks them, pastes them under and adds 4 dashes and spaces to them.
* `#@z` repeats this `#` times
* `ddl4x` deletes the last lines and remove for dashes to the bottom of the cake to make it equal with the top of the bottom layer
* `ggd$i_|_|_` replaces the first line by the top of the cake
* `%ce` then centers the whole cake to the width of the bottom layer! !
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~27~~ 26 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
∫4*I:┌*╗1Ο;@*┐1Ο}⁴¹k┐╔2ΟΚ╚
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUyMjJCNCpJJTNBJXUyNTBDKiV1MjU1NzEldTAzOUYlM0JAKiV1MjUxMDEldTAzOUYlN0QldTIwNzQlQjlrJXUyNTEwJXUyNTU0MiV1MDM5RiV1MDM5QSV1MjU1QQ__,inputs=Mw__)
Explanation:
```
∫ } for each in 1..input inclusive, pushing counter
4* multiply by 4
I increase by 1
: duplicate; this will be used later
┌* repeat a dash pop times
╗1Ο encase them in plusses
; get the duplicate on the stacks top
@* repeat a space pop times
┐1Ο encase in vertical bars
⁴ duplicate the item below ToS - the last line
¹ wrap the stack in an array
k remove the arrays first item
┐ push "_"
╔ push "|"
2Ο encase 2 copies of the vertical bar in underscores
Κ and prepend that to the array
╚ center the array horizontally
```
[Answer]
# Excel VBA, ~~139~~ ~~130~~ 127 Bytes
Anonymous VBE immediate window that takes input from cell `A1` and outputs a cake to the VBE immediate window
```
For i=1To[A1]:s=Space(2*([A1]-i)):x=String(1+4*i,45):?s &IIf(i=1," _|_|_","+" &x &"+"):?s"|"Replace(x,"-"," ")"|":Next:?s"+"x"+
```
[Answer]
# CJam, 79 bytes
```
l~4*):Z5:X{D'+'-C}:A{D'|SC}:B{X*1$N}:C];{SZX-Y/*}:D~" _|_|_"NB{XZ<}{X4+:X;AB}wA
```
[Try it online](http://cjam.aditsu.net/#code=l~4*)%3AZ5%3AX%7BD'%2B'-C%7D%3AA%7BD'%7CSC%7D%3AB%7BX*1%24N%7D%3AC%5D%3B%7BSZX-Y%2F*%7D%3AD~%22%20_%7C_%7C_%22NB%7BXZ%3C%7D%7BX4%2B%3AX%3BAB%7DwA&input=5)
[Answer]
# QBasic, 115 bytes
```
INPUT n
?SPC(n*2-1)"_|_|_
FOR i=1TO n
s=n*2-i*2
?SPC(s)"|"SPC(i*4+1)"|
?SPC(s-2)"+"STRING$(i*4+(i=n)*4+5,45)"+
NEXT
```
### Ungolfed
Print the top line with the candles; then print the rest of the cake two lines at a time.
```
INPUT n
PRINT SPC(n * 2 - 1); "_|_|_"
FOR i = 1 TO n
indent = n * 2 - i * 2
PRINT SPC(indent); "|"; SPC(i * 4 + 1); "|"
PRINT SPC(indent - 2); "+"; STRING$(i * 4 + (i = n) * 4 + 5, 45); "+"
NEXT
```
`SPC`, when used in a `PRINT` statement, emits the given number of spaces. Conveniently, when given a negative argument, it treats it as 0, so the fact that `indent - 2` is `-2` in the last iteration isn't a problem. `STRING$` takes a count and a character code (here, 45 for `-`) and repeats the character that number of times. Here, we have to special-case the last line (when `i=n`) to be 4 hyphens shorter than it would otherwise be.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~158~~ 153 bytes
-5 bytes thanks to ceilingcat.
```
i,l,s;p(c,s){printf("%*c%*.*s%c\n",i-~i,c,l,l,s,c);}f(n){s=memset(malloc(5*n),45,5*n);l=1;for(i=n;i--;p('|',""))l+=4,n+~i?p(43,s):p(32,"_|_|_");p(43,s);}
```
[Try it online!](https://tio.run/##LY7BasNADETP9lcsCyaSLRfS2JeoS3@kUIKIi2C9WbLuyXF@3VWgzOHBMMyM9D8i@64UqXAGoYJrvmtaJvBNK0371pZGvpIn7Z9KYjlLkiBvEyRcS5ivc7kuMF9ivAmMbUIaRnqRYzjydLuDhsTa99Z/eBzIe8TYhYFS99TPDMPJRs8ZTu/kvx8mj/zv8rbbFTdfNAHWa11Zm4OXpS64Ixs@ghuNXYd1VU2gSC7/LgVshett/wM "C (gcc) – Try It Online")
] |
[Question]
[
The goal of this code golf is to convert integers to English words.
The program prompts for input. If this input isn't an integer, print `NaN`. If it is an integer, convert it to English words and print these words. Minimum input: 0 (zero). Maximum input: 9000 (nine thousand).
So, `5` returns `five` (case doesn't matter), and `500` returns `five hundred` or `five-hundred` (dashes don't matter).
Some other rules:
A `one` before `hundred` or `thousand` is optional: `one hundred` is correct, but `hundred` too (if the input is `100` of course).
The word `and` in for example `one hundred and forty five` is optional too.
Whitespace matters. So, for `500`, `five-hundred` or `five hundred` is correct, but `fivehundred` is not.
Good luck!
[Answer]
## JavaScript (375)
Probably a terrible attempt, but anyway, here goes...
```
alert(function N(s,z){return O="zero,one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,,fif,,,eigh,,,,twen,,for".split(","),(z?O[s]||O[s-10]||O[s-20]:s<13?N(s,1):s<20?N(s,1)+"teen":s<100?N(a=20+(s/10|0),1)+"ty"+(s%10?" "+N(s%10):""):s<1e3?N(s/100|0)+" hundred"+(s%100?" "+N(s%100):""):s<1e5?N(s/1e3|0)+" thousand"+(s%1e3?" "+N(s%1e3):""):0)||NaN}(prompt()))
```
Pretty-printed (as a function):
```
function N(s,z) {
return O = "zero,one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,,fif,,,eigh,,,,twen,,for".split(","),
(z? O[s] || O[s-10] || O[s-20]
: s < 13? N(s,1)
: s < 20? N(s,1) + "teen"
: s < 100? N(a=20+(s/10|0),1) + "ty" + (s%10?" "+N(s%10):"")
: s < 1e3? N(s/100|0) + " hundred" + (s%100?" "+N(s%100):"")
: s < 1e5? N(s/1e3|0) + " thousand" + (s%1e3?" "+N(s%1e3):"") : 0) || NaN
}
```
Sample conversion (note that it even outputs `NaN` when out of bounds, i.e. invalid input):
```
540: five hundred forty
4711: four thousand seven hundred eleven
7382: seven thousand three hundred eighty two
1992: one thousand nine hundred ninety two
hutenosa: NaN
1000000000: NaN
-3: NaN
```
[Answer]
# Mathematica ~~60~~ 57
```
f = ToString@#~WolframAlpha~{{"NumberName", 1}, "Plaintext"} &
```
**Usage:**
```
f[500]
```
>
> five hundred
>
>
>
**Edit:**
```
InputString[]~WolframAlpha~{{"NumberName", 1}, "Plaintext"}
```
[Answer]
# Lisp, 72 56 characters
I realize 1) that this is old, and 2) that it relies entirely on the standard library to function, but the fact that you can get the c-lisp printing system to do this kind of thing has always impressed me. Also, this does in fact take the input from a user, convert it, and print it.
```
(format t "~:[NaN~;~:*~r~]" (parse-integer (read-line) :junk-allowed t))
```
It totals 72 characters.
* `:junk-allowed` causes parse-integer to return nil on failure instead of raising an error.
* `~:[if-nil~;if-non-nill]` conditional predicated on nil, handles NaN where necessary
* `~:*` backs up the argument interpretation to re-consume the input
* `~r` prints the number as an english word string, as requested, except with full corrected punctuation
Sample:
```
17823658
seventeen million, eight hundred and twenty-three thousand, six hundred and fifty-eight
192hqfwoelkqhwef9812ho1289hg18hoif3h1o98g3hgq
NaN
```
Lisp info mainly from [Practical Common Lisp](http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec/Body/fun_parse-integer.html).
## Edit, golfed properly down to 56 characters
```
(format t "~:[NaN~;~:*~r~]"(ignore-errors(floor(read))))
```
This version works rather differently. Instead of reading a line and converting it, it invokes the lisp reader to interpret the input as a lisp s-expression, attempts to use it as a number, and if any errors are produced ignores them producing nil to feed the format string conditional. This may be the first instance I've seen of lisp producing a truly terse program... Fun!
* `(read)` Invokes the lisp reader/parser to read one expression from standard input and convert it into an appropriate object
* `(floor)` attempts to convert any numeric type into the nearest lower integer, non-numeric types cause it to raise an error
* `(ignore-errors ...)` does what it says on the tin, it catches and ignores any errors in the enclosed expression, returning nil to feed the NaN branch of the format string
[Answer]
## Perl 281 bytes
```
print+0eq($_=<>)?Zero:"@{[((@0=($z,One,Two,Three,Four,Five,@2=(Six,Seven),
Eight,Nine,Ten,Eleven,Twelve,map$_.teen,Thir,Four,@1=(Fif,@2,Eigh,Nine)))
[$_/1e3],Thousand)x($_>999),($0[($_%=1e3)/100],Hundred)x($_>99),
($_%=100)>19?((Twen,Thir,For,@1)[$_/10-2].ty,$0[$_%10]):$0[$_]]}"||NaN
```
Newlines added for horizontal sanity. The above may be used interactively, or by piping it a value via stdin.
Works correctly for all integer values on the range *[0, 19999]*, values outside this range exhibit undefined behavior. Non-integer values will be truncated towards zero, and as such, only values which are truly non-numeric will report `NaN`.
Sample usage:
```
for $n (14, 42, 762, 2000, 6012, 19791, 1e9, foobar, 17.2, -3) {
print "$n: ", `echo $n | perl spoken-numbers.pl`, $/;
}
```
Sample output:
```
14: Fourteen
42: Forty Two
762: Seven Hundred Sixty Two
2000: Two Thousand
6012: Six Thousand Twelve
19791: Nineteen Thousand Seven Hundred Ninety One
1000000000: Thousand
foobar: NaN
17.2: Seventeen
-3: Nine Hundred Ninety Seven
```
[Answer]
# PHP, ~~327~~ ~~310~~ 308 bytes
```
<?$a=['',one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,0,fif,0,0,eigh];echo($n=$argv[1])>999?$a[$n/1000].' thousand ':'',$n%1000>99?$a[$n/100%10].' hundred ':'',$n?($k=$n%100)<20?($a[$k]?:$a[$k%10]).[teen][$k<13]:[2=>twen,thir,'for',fif,six,seven,eigh,nine][$k/10].'ty '.$a[$k%10]:zero;
```
takes the number as parameter, works for 0<=n<=12999
**breakdown**
```
// define names
$a=['',one,two,three,four,five,six,seven,eight,nine,
ten,eleven,twelve,thir,0,fif,0,0,eigh];
// print ...
echo
($n=$argv[1])>999?$a[$n/1000].' thousand ':'', // thousands
$n%1000>99?$a[$n/100%10].' hundred ':'', // hundreds
$n?
// if remains <20:
($k=$n%100)<20?
($a[$k]?:$a[$k%10]) // no value at index (0,14,16,17,19)? value from index%10
.[teen][$k<13] // append "teen" for $k>12
// else:
:[2=>twen,thir,'for',fif,six,seven,eigh,nine][$k/10].'ty ' // tens
.$a[$k%10] // ones
// "zero" for $n==0
:zero
;
```
[Answer]
# SAS, 70 characters
```
data;window w n;display w;if n=. then put 'NaN';else put n words.;run;
```
The `window` and `display` statements open up the SAS command prompt. Input for `n` goes on line 1. This takes advantage of the SAS format `words.` which will print the number as a word or series of words with "and", " ", and "-" as appropriate.
[Answer]
**PHP**
777 characters
This is definitely a terrible attempt, but you can't accuse me of taking advantage of any loopholes, plus it's a very lucky number. Thanks to ProgramFOX for the tip.
```
<?php $i=9212;$b = array('zero','one','two','three','four','five','six','seven','eight','nine');$t='teen';$c = array('ten','eleven','tweleve','thir'.$t,$b[4].$t,'fif'.$t,$b[6].$t,$b[7].$t,$b[8].$t,$b[9].$t);$d = array('','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninety');$e='hundred';$f='thousand';$j=str_split($i);if (strlen($i)===1){$a=$b[$i];}elseif (strlen($i)===3){$k=1;$a=$b[$j[0]].' '.$e.' '.x($j,$k);}elseif (strlen($i)===4){$k=2;$a=$b[$j[0]].' '.$f.' '.$b[$j[1]].' '.$e.' '.x($j,$k);}elseif (substr($i, -2, 1)==='1'){$a=$c[$j[1]];}else{$a=$d[$j[0]].' '.$b[$j[1]];}$a = str_replace('zero hundred','',$a);echo $a;function x($j,$k){global $i, $b, $c, $d;if (substr($i, -2, 1)==='1'){return $c[$j[$k+1]];}else{return $d[$j[$k]].' '.$b[$j[$k+1]];}}
```
**Long hand**
```
<?php
// Input
$i=9212;
// 0-9
$b = array('zero','one','two','three','four','five','six','seven','eight','nine');
// 10-19 (Very tricky)
$t='teen';
$c = array('ten','eleven','tweleve','thir'.$t,$b[4].$t,'fif'.$t,$b[6].$t,$b[7].$t,$b[8].$t,$b[9].$t);
// Left digit of 20-99
$d = array('','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninety');
// Hundreds
$e='hundred';
// Thousands
$f='thousand';
// Split input
$j=str_split($i);
// 1 digit inputs
if (strlen($i)===1){$a=$b[$i];}
// 3 digit input
elseif (strlen($i)===3){$k=1;$a=$b[$j[0]].' '.$e.' '.x($j,$k);}
// 4 digit input
elseif (strlen($i)===4){$k=2;$a=$b[$j[0]].' '.$f.' '.$b[$j[1]].' '.$e.' '.x($j,$k);}
// 10-19
elseif (substr($i, -2, 1)==='1'){$a=$c[$j[1]];}
// 20-99
else{$a=$d[$j[0]].' '.$b[$j[1]];}
// Fix for thousand numbers
$a = str_replace('zero hundred','',$a);
// Result
echo $a;
// Abstracted function last 2 digits for 3 and 4 digit numbers
function x($j,$k){
global $i, $b, $c, $d;
// 10-19
if (substr($i, -2, 1)==='1'){return $c[$j[$k+1]];}
// 20-99
else{return $d[$j[$k]].' '.$b[$j[$k+1]];}
}
```
[Answer]
# Python 2.x - 378
Derivative of Fireflys answer, although by changing `P` to include million or trillions, etc.. it could recursively be used for any range of positive numbers. This also supports values up to 999,999
```
O=",one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir,,fif,,,eigh,,,,twen,thir,for,fif,,,eigh,".split(",")
P=",thousand".split(',')
def N(s,p=0):
h,s=divmod(s,1000);x=N(h,p+1)if h>0 else" "
if s<20:x+=O[s]or O[s-10]+["","teen"][s>12]
elif s<100:x+=(O[s/10+20]or O[s/10])+"ty"+N(s%10)
else:x+=N(s/100)+"hundred"+N(s%100)
return x+" "+P[p]
print N(input())
```
Sample test (input is `<<<`, output is `>>>`):
```
<<< 1234
>>> one thousand two hundred thirty four
<<< 999999
>>> nine hundred ninety nine thousand nine hundred ninety nine
```
Although, if someone can explain this odd "buffer underflow" issue I have, that'd be swell...
```
<<< -1
>>> nine hundred ninety nine
<<< -2
>>> nine hundred ninety eight
```
[Answer]
# SmileBASIC, ~~365~~ Three Hundred Forty Seven bytes
```
DIM N$[22]D$="OneTwoThreeFourFiveSixSevenEightNineTenElevenTwelveThirFourFifSixSevenEighNineTwenFor
WHILE LEN(D$)INC I,D$[0]<"_
INC N$[I],SHIFT(D$)WEND
INPUT N
W=N MOD 100C%=N/100MOD 10M%=N/1E3T=W<20X=W/10>>0?(N$[M%]+" Thousand ")*!!M%+(N$[C%]+" Hundred ")*!!C%+(N$[X+10+(X==2)*8+(X==4)*7]+"ty "+N$[N MOD 10])*!T+N$[W*T]+"teen"*(T&&W>12)+"Zero"*!N
```
There's a trailing space if the last one or two digits are 0.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 11 bytes
```
⌈≠[`NaN`|∆ċ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLijIjiiaBbYE5hTmB84oiGxIsiLCIiLCJ0b3AgdGVuIGJydWggbW9tZW50cyJd)
Easy win when it's a built-in :p
[Answer]
# Wolfram Language ~~27~~ 40 bytes
Making use of the native function, `IntegerName`,
```
Check[Input[]~IntegerName~"Words","NaN"]
```
The above prompts for user input. The present implementation returns "NaN" if the user enters anything other than an integer.
---
**Some examples (with pre-set inputs)**:
```
Check[243~IntegerName~"Words","NaN"]
```
>
> two hundred forty-three
>
>
>
---
```
Check[1234567890~IntegerName~"Words","NaN"]
```
>
> one billion, two hundred thirty-four million, five hundred
> sixty-seven thousand, eight hundred ninety
>
>
>
---
```
Check["abc"~IntegerName~"Words","NaN"]
```
>
> NaN
>
>
>
[Answer]
# [Python 2](https://docs.python.org/2/), 333 bytes
```
def f(n):S=str.split;D=S('z one two three four five six seven eight nine');K=' fif six seven eigh nine';k=n/1000;n,m=n/100%10,n%100;e,d=m/10,m%10;return' '.join([k and f(k),'thousand']*(k>0)+[D[n],'hundred']*(n>0)+([S('ten eleven twelve thir four'+K)[d]+'teen'*(d>2)]if 9<m<20else[S('twen thir for'+K)[e-2]+'ty']*(e>0)+[D[d]]*(d>0)))
```
[Try it online!](https://tio.run/##XY8/b4MwEMX3fgovlXGgqQ39AyVkypYxI2Ko5KO4wIGMCU2/PDXQCtTF8rt37@537c0UDfrjKCEnuYPs7ZJ0Ru@7tlImPiUXh36TBoGYoSGm0AAkb3pNcnUF0qkv0sEVkID6KAxBhUBZfE6o9fN/9uLGZYKPgnMeo1cv33vBPbQPj8GTSW1LXm1lrMH0Gimh@89GoZOW5B2lZSyZRy1031lJs51THjlz01OKmUeLHqWGuYxT2UntAWYiqGYQM0BlwU2h9HwHdc8slZlrewDpzpFHn2UWPTrUB59D1cE8YJiiS2aJwIM/hW7TIvjdL7NsGsAZY2OrFRrLKsKA3f2JZ/GyiqfgdRW@CEXkbzqjjbd@Q7ERgdg2RSEbfwA "Python 2 – Try It Online")
This is good for 1 to 999,999, inclusive.
[Answer]
# Pyth, ~~239~~ 242 bytes
```
L:rjdb6" +"dAm+cd;"nine"," one two three four five six seven eight"" twen thir for fif six seven eigh"|y_.ey+Wk.e?Y?thZjd,?hZ+@HhZ"ty"""@GeZ@+c"ten eleven twelve"d+R"teen"+c"thir four"d>H5eZ?hZ+@GhZ" hundred"""c.[03_b]1"thousand"c_jQT3"zero
```
Input is an integer in range [0-999,999]. Try it online [here](https://pyth.herokuapp.com/?code=L%3Arjdb6%22++%2B%22dAm%2Bcd%3B%22nine%22%2C%22+one+two+three+four+five+six+seven+eight%22%22++twen+thir+for+fif+six+seven+eigh%22%7Cy_.ey%2BWk.e%3FY%3FthZjd%2C%3FhZ%2B%40HhZ%22ty%22%22%22%40GeZ%40%2Bc%22ten+eleven+twelve%22d%2BR%22teen%22%2Bc%22thir+four%22d%3EH5eZ%3FhZ%2B%40GhZ%22+hundred%22%22%22c.%5B03_b%5D1%22thousand%22c_jQT3%22zero&input=90210&debug=0). Explanation pending.
Previous version, very similar operation, but doesn't support 0:
```
L:rjdb6" +"dJc" one two three four five six seven eight nine"dKc" twen thir for fif six seven eigh nine"dy_.ey+Wk.e?Y?thZjd,?hZ+@KhZ"ty"""@JeZ@+c"ten eleven twelve"d+R"teen"+c"thir four"d>K5eZ?hZ+@JhZ" hundred"""c.[03_b]1"thousand"c_jQT3
```
Explanation of previous version:
```
Implicit: Q=eval(input()), d=" "
Step 1: output formatting helper function
L:rjdb6" +"d
L Define a function, y(b):
jdb Join b on spaces
r 6 Strip whitespace from beginning and end
: In the above, replace...
" +" ... strings of more than one space...
d ... with a single space
Step 2: Define number lookup lists
Jc"..."dKc"..."d
"..." Lookup string
c d Split the above on spaces
J Store in J - this is list of unit names
Kc"..."d As above, but storing in K - this is list of tens names, without "ty"
Step 3: Bringing it all together
y_.ey+Wk.e?Y?thZjd,?hZ+@KhZ"ty"""@JeZ@+c"ten eleven twelve"d+R"teen"+c"thir four"d>K5eZ?hZ+@JhZ" hundred"""c.[03_b]1"thousand"c_jQT3
jQT Get digits of Q
_ Reverse
c 3 Split into groups of 3
.e Map the above, element as b, index as k, using:
_b Reverse the digits in the group
.[03 Pad the above on the left with 0 to length 3
c ]1 Chop at index 1 - [1,2,3] => [[1],[2,3]]
.e Map the above, element as Z, index as Y, using:
?Y If second element in the group (i.e. tens and units):
?thZ If (tens - 1) is non-zero (i.e. 0 or >=2):
?hZ If tens is non-zero:
@KhZ Lookup in tens names
+ "ty" Append "ty"
Else:
"" Empty string
, Create two-element list of the above with...
@JeZ ... lookup units name
jd Join the above on a space - this covers [0-9] and [20-99]
Else:
c"thir four"d ["thir", "four"]
+ >K5 Append last 5 element of tens names ("fif" onwards)
+R"teen" Append "teen" to each string in the above
+c"ten eleven twelve"d Prepend ["ten", "eleven", "twelve"]
@ eZ Take string at index of units column - this covers [10-19]
Else: (i.e. hundreds column)
?hZ If hundreds column is non-zero:
@JhZ Lookup units name
+ " hundred" Append " hundred"
"" Else: empty string
Result of map is two element list of [hundreds name, tens and units name]
Wk If k is nonzero (i.e. dealing with thousands group)...
+ "thousand" ... Append "thousand"
y Apply output formatting (join on spaces, strip, deduplicate spaces)
Result of map is [units group string, thousands group string]
_ Reverse group ordering to put thousands back in front
y Apply output formatting again, implicit print
```
[Answer]
# [MOO](https://en.wikipedia.org/wiki/MOO_(programming_language)) - ~~55~~ 83 bytes
```
x=$code_utils:toint(read(p=player));p:tell(x==E_TYPE?"NaN"|$string_utils:english_number(x))
```
Note: this code does not print any prompt to the standard output.
As a bonus, this code can handle any number withing the bounds of the moo language (`2147483647`-`-2147483648`).
] |
[Question]
[
The goal of this challenge is to receive an input and output that input but with sentence order reversed.
Example Input:
```
Hello friend. What are you doing? I bet it is something I want to do too!
```
Example Output:
```
I bet it is something I want to do too! What are you doing? Hello friend.
```
As you can tell from the examples, your program has to deal with question marks, exclamation points, and periods. You can assume each sentence has a punctuation and than a space before the next sentence. Trailing spaces/newlines are ok, as long as it is readable.
Shortest code wins.
Good luck!
EDIT: You can assume the sentences has no quotes or parentheses, but if you make your code be able to deal with both of those then you get **-5 bytes** Example output for parens/quotes:
```
"Hello, " she said. (I didn't know what she was talking about.) --> (I didn't know what she was talking about.) "Hello, " she said.
```
[Answer]
# Julia, ~~45~~ 42 bytes - 5 bonus = 37
```
s->join(reverse(split(s,r"[.?!]\K "))," ")
```
This creates an anonymous function that accepts a string as input and returns the string with its sentences reversed. This handles any special character appropriately, though double quotes and dollar signs must be escaped, otherwise they aren't valid strings in Julia.
Ungolfed + explanation:
```
function f(s)
# Get individual sentences by splitting on the spaces that
# separate them. Spaces are identified by matching punctuation
# then moving the position beyond that match and matching a
# space. This is accomplished using \K.
sentences = split(s, r"[.?!]\K ")
# Reverse the order of the array of sentences.
reversed_order = reverse(sentences)
# Join the array elements into a string, separated by a space.
join(reversed_order, " ")
end
```
Examples:
```
julia> f("Hello friend. What are you doing? I bet it is something I want to do too!")
"I bet it is something I want to do too! What are you doing? Hello friend."
julia> f("\"Hello, \" she said. (I didn't know what she was talking about.)")
"(I didn't know what she was talking about.) \"Hello, \" she said."
```
And if you don't like looking at the escaped quotes in the output:
```
julia> println(f("\"Hello, \" she said. (I didn't know what she was talking about.)"))
(I didn't know what she was talking about.) "Hello, " she said.
```
Saved 3 bytes on the regular expression thanks to Martin Büttner! Previously this used a lookbehind: `(?<=[.?!])`.
[Answer]
# CJam, ~~23~~ 22 bytes
I am not sure if this qualifies for the bonus or not, but here goes the solution:
```
Sq{1$".?!"-{])[}|}%]W%
```
**Code Expansion (bit outdated)**:
```
Sq+ e# Read the input and prepend with a space
{ }% e# For each input character
_".?!"& e# Copy and check if its one of ., ? and !
{][}& e# If it is one of the above, wrap everything till now in an array
e# and start a new array to be wrapped next time we get one of those
e# three characters. We now have an array of strings, each having
e# a single sentence
W% e# Reverse the ordering of these sentences
s( e# Convert to string and remove the first space
```
[Try it online here](http://cjam.aditsu.net/#code=Sq%7B1%24%22.%3F!%22-%7B%5D)%5B%7D%7C%7D%25%5DW%25&input=Hello%20friend.%20What%20are%20you%20doing%3F%20I%20bet%20it%20is%20something%20I%20want%20to%20do%20too!)
[Answer]
# J, 35 32
It almost handles bonus input, except I have to escape single apostrophes, so I guess it doesn't count. (Also, my first submission here)
```
f=.;@|.@(]<;.2~'.?!'e.~])@,~&' '
```
Usage:
```
f 'Hello friend. What are you doing? I bet it is something I want to do too!'
```
[Answer]
# Perl, 27/25
```
#!perl -n
print reverse/ |[^.!?]*./g
```
Or from the command line:
```
$perl -nE'say reverse/ |[^.!?]*./g'
```
[Answer]
## PHP, 60
```
echo join(' ',array_reverse(preg_split('/(?<=[?!.])/',$s)));
```
[Answer]
# Bash + coreutils, 40 bytes
```
sed 's/\([?.!]\) */\1\n/g'|tac|tr \\n \
```
This reads from STDIN so input may me redirected in from a file, or simply piped in, e.g.:
```
$ printf 'Hello friend. What are you doing? I bet it is something I want to do too!' | sed 's/\([?.!]\) */\1\n/g'|tac|tr \\n \
I bet it is something I want to do too! What are you doing? Hello friend.
$
```
[Answer]
# [Pip](http://github.com/dloscutoff/pip), 25 bytes
```
a.:sRV(a^@2+$ALa@*^".?!")
```
After appending a space to the input string, we find all indices of `.`, `?`, and `!`, add 2, and use the `^@` split-at operator to break the string into sentences (each with a trailing space). Reverse the list, and it's auto-printed at the end of the program. Voilà!
Example showing the stages of the main computation with input `A! B? C. D!`:
```
^".?!" ["." "?" "!"]
a@* [[7] [4] [1 10]]
$AL [7 4 1 10]
2+ [9 6 3 12]
a^@ ["A! " "B? " "C. " "D! "]
RV( ) ["D! " "C. " "B? " "A! "]
D! C. B? A!
```
[Answer]
# [Retina](https://github.com/mbuettner/retina), ~~61~~ ~~34~~ ~~33~~ 30 bytes
*Credits to nutki for cutting this down by 24 bytes.*
```
^
#
+`(#.*[.!?]) (.+)
$2 $1
#
<empty>
```
Where `<empty>` stands for an empty line. This assumes that `#` is not part of the input, but if that's not legitimate, I could swap it out for any other character, including `"` (which I'd only need to handle for the bonus) or something unprintable. You can run the code like that in a single file if you use the `-s` flag, or you can put each line in a separate file and pass them all to Retina.
Reversing this with a single regex replacement is possible, but really cumbersome. Even with .NET balancing groups I needed something around 90 bytes, so instead I tried doing it in multiple steps.
In Retina, every pair of lines is one replacement stage, where the first line is the pattern and the second line is the replacement.
```
^
#
```
This stage simply prepares the string for further processing. It prepends a `#` as a marker. This marker indicates that everything in front of it has already been put in the right place, and everything after it still needs to be processed.
```
+`(#.*[.!?]) (.+)
$2 $1
```
This stage swaps the sentences, by repeatedly moving the last sentence in front of the `#` (which moves forwards through the string in the process). The `+`` instructs Retina to repeat this stage until the output stops changing. As an example, here is how the input `foo. bar! blah?` would be processed:
```
#foo. bar! blah?
blah? #foo. bar!
blah? bar! #foo.
```
And finally we simply remove the marker:
```
#
<empty>
```
[Answer]
# Java, 113
```
s->{String t[]=s.split("(?<=[\\.?!]) "),u="";for(int i=t.length;i-->0;)u+=t[i]+" ";return u.replaceAll(".$","");}
```
[Answer]
# JavaScript (ES6) 47 ~~45~~
As it's stated, it's a simple regex exercise. In javascript:
```
// ES6 - FireFox only
F=t=>t.match(/\S[^.!?]+./g).reverse().join(' ')
// ES5 - so much longer
function G(t){return t.match(/\S[^.!?]+./g).reverse().join(' ')}
// TEST
alert(G("Hello friend. What are you doing? I bet it is something I want to do too!"))
```
[Answer]
# Python 2, 62
Not going to improve for the bonus, as it's probably not worth the byte cost.
```
import re
print' '.join(re.split('(?<=[?!.]).',input())[::-1])
```
[Answer]
# Matlab (93 bytes)
```
y=[32 input('','s')];y=sortrows([cumsum(ismember(y,'?!.'),'reverse');y]',1)';disp(y(4:2:end))
```
* This assumes the input doesn't contain leading or trailing spaces
* Uses standard input and output
* Tested in Matlab 2014b
[Answer]
# Ruby 41
The other Ruby answers don't have enough WTF.
```
#!ruby -apF(?<=[.!?])\s
$_=$F.reverse*" "
```
This at least works in Ruby 2. If the `a` and `F` switch works in 1.8.7, I guess you could drop `$_=` to save three characters.
Reverses every line on stdin and print to stdout:
```
$ ruby foo.rb <<< "Hello. Hi. How are you? Good, you? fine, thanks."
fine, thanks. Good, you? How are you? Hi. Hello.
```
[Answer]
# Ruby, 48(42 without the puts) bytes
reverse\_sentence.rb
```
puts $*[0].scan(/\S[^.!?]+./).reverse.join(" ")
```
Usage:
```
ruby reverse_sentence.rb 'Hello friend. What are you doing? I bet it is something I want to do too!'
```
Output:
```
I bet it is something I want to do too! What are you doing? Hello friend.
```
Criticism more than welcome.
[Answer]
# k, 31
```
{1_,/|(0,1+&x in"?!.")_x:" ",x}
```
.
```
k){1_,/|(0,1+&x in"?!.")_x:" ",x} "Hello friend. What are you doing? I bet it is something I want to do too!"
"I bet it is something I want to do too! What are you doing? Hello friend."
```
[Answer]
**C# - LINQPAD - 93 - 5 = 88 bytes**
```
void Main(){string.Join(" ",Regex.Split(Console.ReadLine(),"(?<=[.?!]) ").Reverse()).Dump();}
```
**C# Console App 189 - 5 = 184 bytes**
```
using System;using System.Linq;using System.Text.RegularExpressions;class P{static void Main(){Console.WriteLine(string.Join(" ",Regex.Split(Console.ReadLine(), "(?<=[.?!]) ").Reverse()));}}
```
*regex shamelessly flogged from Alex A. :)*
[Answer]
# Clojure - 44 71 chars
```
(defn rs[s](reverse(re-seq #"\S.+?[.!?]"s)))
```
Improved and simplified RE, eliminated unnecessary whitespace.
Output is a sequence of the sentences in the original string, with the order of the sentences reversed:
Input: "Hello friend. What are you doing? I bet it is something I want to do too!"
Output: ("I bet it is something I want to do too!" "What are you doing?" "Hello friend.")
[Answer]
# Ruby, 47
```
$><<gets.strip.split(/(?<=[.?!]) /).reverse*' '
```
credits to [Martin Büttner](https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner), for saving some characters.
[Answer]
# CJam, 21 bytes
```
1q{1?_"!.?"-}%1a/W%S*
```
This works by turning spaces after `!`s, `.`s and `?`s into the number 1 (not the *character* 1 nor the character with code point 1, so the input can still contain those), splitting at 1's, reversing the order of the resulting chunks and joining by spaces.
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=1q%7B1%3F_%22!.%3F%22-%7D%251a%2FW%25S*&input=Hello%20friend.%201%20is%20number%20one!%20What%20are%20you%20doing%3F%20I%20bet%20it%20is%20something%20I%20want%20to%20do%20too!).
### How it works
```
1 e# B := 1
q e# Q := input()
{ }% e# for each C in Q (map):
1? e# C := B ? C : 1
_"!.?"- e# B := string(C).strip("!.?")
1a/ e# Q := Q.split([1])
W% e# Q := reverse(Q)
S* e# Q := Q.join(" ")
e# print(Q)
```
] |
[Question]
[
**This question already has answers here**:
[Discrete Convolution or Polynomial Multiplication](/questions/80030/discrete-convolution-or-polynomial-multiplication)
(16 answers)
[Factor a polynomial over a finite field or the integers](/questions/38513/factor-a-polynomial-over-a-finite-field-or-the-integers)
(1 answer)
Closed 7 years ago.
*For all you American folk out there, remove the "s" in "maths".*
Ugh, my maths teacher gave me so much algebra to do. There's just lines and lines of meaningless junk like `Expand (x+1)(x+6)` and `Factorise x^2+2x+1`.
My hands are literally dying from the inside.
So I figured out a way to hack the system - why not write a program in my book (and tell the teacher to run it)? It's genius!
Your task is to either expand or factorise the function listed. My hand's already dying, so I need to write as small a program as possible to save my fingers.
# Input:
* The input is either `Expand {insert algebra here}` or `Factorise {insert algebra here}`.
* When the first word is `Expand`, you must expand the algebraic terms. You are guaranteed there won't be more than 5 terms.
+ In the example shown in the intro, the output is `x^2+7x+6`.
+ Some more inputs:
- `Expand (x+1)(x-1)` = `x^2-1`
- `Expand x(x-1)(x+1)` = `x^3-x` (notice the `x` on its own - your program must work for that.)
- `Expand (x+1)^2` = `x^2+2x+1` (notice the `^2` on the outside of `x+1` - your program must work for that.)
* When the first word is `Factorise`, you must factorise the algebraic term.
+ In the example shown in the intro, the output is `(x+1)^2`.
+ Some more inputs:
- `Factorise x^2+3x+2` = `(x+1)(x+2)`
- `Factorise x^2+x` = `x(x+1)` (if `x` alone is one of the factors, you must leave it outside the brackets.)
- `Factorise x^3+9x^2+26x+24` = `(x+2)(x+3)(x+4)` (there are more than 2 terms here - you are guaranteed that the maximum amount of terms is 5.)
- `Factorise x^2+2x+1` = `(x+1)^2` (if there are multiple repeating terms, group them together - so no `(x+1)(x+1)`, but `(x+1)^2`.
# Specs:
* The pronumeral will always be `x`.
* The terms in the `Expand` bit always contain whole numbers from 1 to 20.
* You are guaranteed that the algebra bit in the `Factorise` part will always be factorised into 5 or less terms, and all the numbers in each term will be whole, and from 1 to 20.
* You are not allowed to use any built-in functions.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest program in bytes wins.
*Just as a side-note: it would be appreciated if a pretty-printed output (i.e. With nice-looking exponents) - I'm looking at you, Mathematica - was included in an answer. You don't have to do it.*
]
|
[Question]
[
A happy number is defined by the following process. Starting with any positive integer, replace the number by the sum of the squares of its digits, and repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those numbers for which this process ends in 1 are happy numbers, while those that do not end in 1 are unhappy numbers (or sad numbers). Given a number print whether it is happy or unhappy.
```
Sample Inputs
7
4
13
Sample Outputs
Happy
Unhappy
Happy
```
Note: Your program should not take more than 10 secs for any number below 1,000,000,000.
[Answer]
## Ruby, 77 characters
```
a=gets.to_i;a=eval"#{a}".gsub /./,'+\&**2'until a<5
puts a<2?:Happy: :Unhappy
```
[Answer]
## C - 115
```
char b[1<<30];a;main(n){for(scanf("%d",&n);b[n]^=1;n=a)for
(a=0;a+=n%10*(n%10),n/=10;);puts(n-1?"Unhappy":"Happy");}
```
This uses a 230-byte (1GB) array as a bitmap to keep track of which numbers have been encountered in the cycle. On Linux, this actually works, and efficiently so, provided [memory overcommitting](http://opsmonkey.blogspot.com/2007/01/linux-memory-overcommit.html) is enabled (which it usually is by default). With overcommitting, pages of the array are allocated and zeroed on demand.
Note that compiling this program on Linux uses a gigabyte of RAM.
[Answer]
## Golfscript - 34 chars
```
~{0\`{48-.*+}/}9*1="UnhH"3/="appy"
```
Basically the same as [this](https://stackoverflow.com/questions/3543811/code-golf-happy-primes/3556849#3556849) and [these](http://golf.shinh.org/p.rb?happy%20number#GolfScript).
The reason for 9 iterations is described in [these comments](https://stackoverflow.com/questions/3543811/code-golf-happy-primes/3544162#3544162) (this theoretically returns correct values up to about `10^10^10^974` ([A001273](http://oeis.org/A001273))).
[Answer]
## Haskell - 77
```
f 1="Happy"
f 4="Unhappy"
f n=f$sum[read[c]^2|c<-show n]
main=interact$f.read
```
[Answer]
### Golfscript, 49 43 41 40 39 chars
```
~{0\10base{.*+}/.4>}do(!"UnhH"3/="appy"
```
Every happy number converges to 1; every unhappy number converges to a cycle containing 4. Other than exploiting that fact, this is barely golfed at all.
(Thanks to Ventero, from whose Ruby solution I've nicked a trick and saved 6 chars).
[Answer]
## Python - 81 chars
```
n=input()
while n>4:n=sum((ord(c)-48)**2for c in`n`)
print("H","Unh")[n>1]+"appy"
```
Some inspiration taken from Ventero and Peter Taylor.
[Answer]
**eTeX, 153**
```
\let~\def~\E#1{\else{\fi\if1#1H\else Unh\fi appy}\end}~\r#1?{\ifnum#1<5
\E#1\fi~\s#1{0?}}~\s#1{+#1*#1\s}~~{\expandafter\r\the\numexpr}\message{~\noexpand
```
Called as `etex filename.tex 34*23 + 32/2 ?` (including the question mark at the end). Spaces in the expression don't matter.
EDIT: I got down to **123**, but now the output is dvi (if compiled with `etex`) or pdf (if compiled with `pdfetex`). Since TeX is a typesetting language, I guess that's fair.
```
\def~{\expandafter\r\the\numexpr}\def\r#1?{\ifnum#1<5 \if1#1H\else
Unh\fi appy\end\fi~\s#1{0?}}\def\s#1{+#1*#1\s}~\noexpand
```
[Answer]
## Javascript (~~94~~ ~~92~~ ~~87~~ 86)
```
do{n=0;for(i in a){n+=a[i]*a[i]|0}a=n+''}while(n>4);alert(['H','Unh'][n>1?1:0]+'appy')
```
Input is provided by setting a to the number desired.
Credits to mellamokb.
[Answer]
## Python (98, but too messed up not to share)
```
f=lambda n:eval({1:'"H"',4:'"Unh"'}.get(n,'f(sum(int(x)**2for x in`n`))'))
print f(input())+"appy"
```
Way, way too long to be competitive, but perhaps good for a laugh. It does "lazy" evaluation in Python. Really quite similar to the Haskell entry now that I think about it, just without any of the charm.
[Answer]
## dc - 47 chars
```
[Unh]?[[I~d*rd0<H+]dsHxd4<h]dshx72so1=oP[appy]p
```
Brief description:
`I~`: Get the quotient and remainder when dividing by 10.
`d*`: Square the remainder.
`0<H`: If the quotient is greater than 0, repeat recursively.
`+`: Sum the values when shrinking the recursive stack.
`4<h`: Repeat the sum-of-squares bit while the value is greater than 4.
[Answer]
## Befunge, 109
Returns correct values for 1<=n<=109-1.
```
v v < @,,,,,"Happy"< >"yppahnU",,,,,,,@
>&>:25*%:*\25*/:#^_$+++++++++:1-!#^_:4-!#^_10g11p
```
[Answer]
# J, 56
```
'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
```
A verb rather than a standalone script since the question is ambiguous.
Usage:
```
happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
happy"0 (7 4 13)
happy"0 (7 4 13)
Happy
Unhappy
Happy
```
[Answer]
## Scala, 145 chars
```
def d(n:Int):Int=if(n<10)n*n else d(n%10)+d(n/10)
def h(n:Int):Unit=n match{
case 1=>println("happy")
case 4=>println("unhappy")
case x=>h(d(x))}
```
[Answer]
# J (50)
```
'appy',~>('Unh';'H'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)
```
I'm sure a more competent J-er than I can make this even shorter. I'm a relative newb.
New and improved:
```
('Unhappy';'Happy'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)
```
Newer and even more improved, thanks to ɐɔıʇǝɥʇuʎs:
```
(Unhappy`Happy){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)
```
[Answer]
# Python (91 characters)
```
a=lambda b:b-1and(b-4and a(sum(int(c)**2for c in`b`))or"Unh")or"H";print a(input())+"appy"
```
[Answer]
# Common Lisp 138
```
(format t"~Aappy~%"(do((i(read)(loop for c across(prin1-to-string i)sum(let((y(digit-char-p c)))(* y y)))))((< i 5)(if(= i 1)"H""Unh"))))
```
More readable:
```
(format t "~Aappy~%"
(do
((i (read)
(loop for c across (prin1-to-string i)
sum (let
((y (digit-char-p c)))
(* y y)))))
((< i 5) (if (= i 1) "H" "Unh"))))
```
Would be shorter to just return "Happy" or "Unhappy" right from the `(do)`, but arguably that wouldn't count as a whole program
[Answer]
# K, 43
```
{{$[4=d:+/a*a:"I"$'$x;unhappy;d]}/x;`happy}
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 17 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
D²SµÐLỊị“¢*X“<@Ḥ»
```
**[Try it online!](https://tio.run/nexus/jelly#@@9yaFPwoa2HJ/g83N31cHf3o4Y5hxZpRQApG4eHO5Yc2v3//39LKDAFAA "Jelly – TIO Nexus")**
### How?
```
D²SµÐLỊị“¢*X“<@Ḥ» - Main link: n
µÐL - loop while the accumulated unique set of results change:
D - cast to a decimal list
² - square (vectorises)
S - sum
- (yields the ultimate result, e.g. n=89 yields 58 since it enters the
- "unhappy circle" at 145, loops around to 58 which would yield 145.)
Ị - insignificant? (abs(v)<=1 - in this case, 1 for 1, 0 otherwise)
“¢*X“<@Ḥ» - dictionary lookup of ["Happy", "Unhappy"] (the central “ makes a list)
ị - index into
- implicit print
```
[Answer]
# [Perl 5](https://www.perl.org/), 62 + 1 (`-p`) = 63 bytes
```
$_=eval s/./+$&**2/gr while$_>1&&!$k{$_}++;$_=un x($_>1).happy
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3ja1LDFHoVhfT19bRU1Ly0g/vUihPCMzJ1Ul3s5QTU1RJbtaJb5WW9saqLQ0T6FCAySuqZeRWFBQ@R8oqGerom@tmm2roWn934TL0JjL/F9@QUlmfl7xf11fUz0DQ4P/ugUA "Perl 5 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 21 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
'ŽØs[SnOD5‹#}≠i„unì}™
```
[Try it online](https://tio.run/##ASsA1P9vc2FiaWX//yfFvcOYc1tTbk9ENeKAuSN94omgaeKAnnVuw6x94oSi//83) or [verify the first 100 test cases](https://tio.run/##ATsAxP9vc2FiaWX/0YJFTsOQVj8iIOKGkiAiP/8nxb3DmHNbU25PRDXigLkjfeKJoGnigJ51bsOsfeKEov8s/w).
**Explanation:**
Each number will eventually result in either `1` or `4`, so we loop indefinitely, and stop as soon as the number is below 5.
```
'ŽØ '# Push string "happy"
s # Swap to take the (implicit) input
[ } # Loop indefinitely
S # Convert the integer to a list of digits
n # Square each
O # Take the sum
D5‹# # If this sum is smaller than 5: stop the infinite loop
≠i } # If the result after the loop is NOT 1:
„unì # Prepend string "un" to string "happy"
™ # Convert the string to titlecase (and 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 `"happy"`.
[Answer]
# [Python 2](https://docs.python.org/2/), 71 bytes
```
f=lambda n:n>4and f(sum(int(d)**2for d in`n`))or("H","Unh")[n>1]+"appy"
```
[Try it online!](https://tio.run/##FcyxCoMwFAXQuX7F4015NotWKAh17g90EsFICAbqTUjt4NfHuB9OPPY1oM3Zvb5mW6wh9Bg6A0tO/f6b8tiVlbpuXUhkyWPGLBKS4jdr/mBlGTE0051NjAfni/nCaHxq6jQ1j6mvbjGVp4xe8gk "Python 2 – Try It Online")
...or, for the same byte count:
```
f=lambda n:n>4and f(eval('**2+'.join(`n*10`)))or("H","Unh")[n>1]+"appy"
```
[Try it online!](https://tio.run/##DcxBCsIwEADAs75i2UuzaRBTC0LBnv2Ap1LoSg1dqZsQitDXR@cBk/ZtidqUEm4rf54zg3bat6wzBPP68moqa5u6Or2jqJnU@vNERDEbvKPDhy5Ig/Z@rJFT2rGEmEFAFIarg9aBv4zd8ZCy6PYfhcoP "Python 2 – Try It Online")
[Answer]
# Perl 5 - 77 Bytes
```
{$n=$_*$_ for split//,$u{$n}=$n;exit warn$/.'un'[$n==1].'happy'if$u{$n};redo}
```
$n is the input value
[Answer]
# C++ 135 , 2 Lines
```
#include<iostream>
int n,i,j;int main(){for(std::cin>>n;n>1;n=++j&999?n*n+i:0)for(i=0;n/10;n/=10)i+=n%10*(n%10);std::cout<<(n?"H":"Unh")<<"appy";}
```
This is a modified version of the one I did here:
<https://stackoverflow.com/questions/3543811/code-golf-happy-primes/3545056#3545056>
[Answer]
Yes, this challenge has three years; yes, it already has a winner answer; but since I was bored and done this for another challenge, thought I might put it up here. Surprise surprise, its long - and in...
# Java - ~~280~~ 264 bytes
```
import java.util.*;class H{public static void main(String[]a){int n=Integer.parseInt(new Scanner(System.in).nextLine()),t;while((t=h(n))/10!=0)n=t;System.out.print(t==1?"":"");}static int h(int n){if(n/10==0)return n*n;else return(int)Math.pow(n%10,2)+h(n/10);}}
```
Ungolfed:
```
import java.util.*;
class H {
public static void main(String[] a) {
int n = Integer.parseInt(new Scanner(System.in).nextLine()), t;
while ((t = h(n)) / 10 != 0) {
n = t;
}
System.out.print(t == 1 ? "" : "");
}
static int h(int n) {
if (n / 10 == 0) {
return n * n;
} else {
return (int) Math.pow(n % 10, 2) + h(n / 10);
}
}
}
```
[Answer]
# C# 94 bytes
```
int d(int n)=>n<10?n*n:(d(n%10)+d(n/10));string h(int n)=>n==1?"happy":n==4?"unhappy":h(d(n));
```
For any given number (as `int`), `h()` will return the correct value. You can try the code on [.NetFiddle](https://dotnetfiddle.net/piCL9v).
Kudos to [user unknown](https://codegolf.stackexchange.com/users/373/user-unknown) for the original [algorithm](https://codegolf.stackexchange.com/a/2286/15214).
[Answer]
## Clojure, ~~107~~ 97 bytes
Update: Removed unnecessary `let` binding.
```
#(loop[v %](case v 1"Happy"4"Unhappy"(recur(apply +(for[i(for[c(str v)](-(int c)48))](* i i))))))
```
Original:
```
#(loop[v %](let[r(apply +(for[i(for[c(str v)](-(int c)48))](* i i)))](case r 1"Happy"4"Unhappy"(recur r))))
```
First time using a nested `for` :o
[Answer]
# R, ~~117~~ 91 bytes
-16 bytes thanks to Giuseppe
```
a=scan();while(!a%in%c(1,4))a=sum((a%/%10^(0:nchar(a))%%10)^2);`if`(a-1,'unhappy','happy')
```
[Answer]
# Julia 1.5 , 188 bytes (without indent)
```
f(s)=sum([parse(Int64,i)^2 for i in string(s)])
function g(s)
a=[f(s)]
while true;h=f(last(a))
if h in a
println("unhappy")
break
elseif h==1
println("Happy")
break
end
append!(a,h)
end
end
```
[Try it online!](https://tio.run/##XY5BDsIgEEXXzimwK0i6EG10hXvP0NRkVJBRpA3QqKdH2oUmLiaT@fPy8m@jI5SvnA2PQsXxwdsBQ9T84NO2qUkc18z0gREjz2IK5K8F7ASY0Z8T9Z5NN6BqJ0EHT0tOM7lfgVWGO4yJoxBAhtnJgDAURXKeV6O3OAzvSsApaLyDdlFPmFLyB/0h/gIlKGvJsbZiDsrkb8O2qXe13HSwuHKa//kD)
] |
[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 7 years ago.
[Improve this question](/posts/84376/edit)
# Task
Find a sequence of all numbers between min and max where every number differs from every other number in the sequence by at least "d" digits.
# Example of sub-sequence
For min = 0, max = 1000 and d = 2, the following is part of one possible solution sequence:
* 123 ← Good
* 132 ← Good
* 145 ← Good
* 146 ← Bad
# Notes
This is a bit practical. I was thinking about this as a problem that has kept cropping up over the years. Basically it's a pattern in URL shorteners / prize codes / conference room codes / etc...
I'd like to be able to hand out codes from a list, and have each code be:
A - Simple to type, and B - Be somewhat unlikely to accidentally conflict with another code because of a typing mistake.
There's no reason to work in base ten. I've expressed the problem that way for clarity, but in real cases we'd take advantage of letters as well.
### Sub-Note
This is not *that* practical. If you use just six "digits" (allowing numbers and capital letters), then you have over two billion choices. That seems like plenty for most cases except for the URL shortener. Still I was thinking it would be nice to be able to generate a random number from that space and be able to quickly check that it was at least "d" different from all others that had been handed out up to that point. Generating a solution sequence is not quite the same problem, but it seemed interesting and I'm hoping that someone comes up with a clever way to structure the data in order to make it efficient to search for these near collisions.
[Answer]
Here's a terrible, brute force way of generating a sequence. I haven't attempted to do much to make it fast, though there are probably several simple gains to be had here. I'm trying to think of a way to make this at least a couple of orders of magnitude faster rather than finding improvements of a few percent.
```
public static IEnumerable<int> GetDifferentCodes(int min, int digits, int minDifference)
{
var max = Math.Pow(10, digits) - 1;
var goodCodes = new List<int>();
var goodCodeDigits = new List<short[]>();
for (var i = min; i < max; i++)
{
var newDigits = GetDigits(i, digits);
if (!goodCodeDigits.All(goodCode => HasMinDiff(goodCode, newDigits, digits, minDifference)))
continue;
goodCodes.Add(i);
goodCodeDigits.Add(newDigits);
}
return goodCodes;
}
private static readonly int[] Powers = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000};
private static short[] GetDigits(int num, int digits)
{
var ret = new short[digits];
for (var i = 0; i < digits; i++)
{
ret[i] = (short) ((num/Powers[i]) % 10);
}
return ret;
}
private static bool HasMinDiff(short[] goodDigits, short[] digitsToCheck, int digits, int minDiff)
{
var difference = 0;
for (var i = 0; i < digits; i++)
{
if (goodDigits[i] == digitsToCheck[i]) continue;
if (++difference >= minDiff) return true;
}
return false;
}
```
] |
[Question]
[
You must evaluate a string written in [Reverse Polish notation](http://en.wikipedia.org/wiki/Reverse_Polish_notation) and output the result.
The program must accept an input and return the output. For programming languages that do not have functions to receive input/output, you can assume functions like readLine/print.
You are not allowed to use any kind of "eval" in the program.
Numbers and operators are separated by one **or more** spaces.
You must support at least the +, -, \* and / operators.
You need to add support to negative numbers (for example, `-4` is not the same thing as `0 4 -`) and floating point numbers.
**You can assume the input is valid and follows the rules above**
## Test Cases
Input:
```
-4 5 +
```
Output:
```
1
```
---
Input:
```
5 2 /
```
Output:
```
2.5
```
---
Input:
```
5 2.5 /
```
Output:
```
2
```
---
Input:
```
5 1 2 + 4 * 3 - +
```
Output:
```
14
```
---
Input:
```
4 2 5 * + 1 3 2 * + /
```
Output:
```
2
```
[Answer]
## Ruby - 95 77 characters
```
a=[]
gets.split.each{|b|a<<(b=~/\d/?b.to_f: (j,k=a.pop 2;j.send b,k))}
p a[0]
```
Takes input on stdin.
### Testing code
```
[
"-4 5 +",
"5 2 /",
"5 2.5 /",
"5 1 2 + 4 * 3 - +",
"4 2 5 * + 1 3 2 * + /",
"12 8 3 * 6 / - 2 + -20.5 "
].each do |test|
puts "[#{test}] gives #{`echo '#{test}' | ruby golf-polish.rb`}"
end
```
gives
```
[-4 5 +] gives 1.0
[5 2 /] gives 2.5
[5 2.5 /] gives 2.0
[5 1 2 + 4 * 3 - +] gives 14.0
[4 2 5 * + 1 3 2 * + /] gives 2.0
[12 8 3 * 6 / - 2 + -20.5 ] gives 10.0
```
Unlike the C version this returns the last valid result if there are extra numbers appended to the input it seems.
[Answer]
## Python - 124 chars
```
s=[1,1]
for i in raw_input().split():b,a=map(float,s[:2]);s[:2]=[[a+b],[a-b],[a*b],[a/b],[i,b,a]]["+-*/".find(i)]
print s[0]
```
**Python - 133 chars**
```
s=[1,1]
for i in raw_input().split():b,a=map(float,s[:2]);s={'+':[a+b],'-':[a-b],'*':[a*b],'/':[a/b]}.get(i,[i,b,a])+s[2:]
print s[0]
```
[Answer]
## Scheme, 162 chars
(Line breaks added for clarity—all are optional.)
```
(let l((s'()))(let((t(read)))(cond((number? t)(l`(,t,@s)))((assq t
`((+,+)(-,-)(*,*)(/,/)))=>(lambda(a)(l`(,((cadr a)(cadr s)(car s))
,@(cddr s)))))(else(car s)))))
```
Fully-formatted (ungolfed) version:
```
(let loop ((stack '()))
(let ((token (read)))
(cond ((number? token) (loop `(,token ,@stack)))
((assq token `((+ ,+) (- ,-) (* ,*) (/ ,/)))
=> (lambda (ass) (loop `(,((cadr ass) (cadr stack) (car stack))
,@(cddr stack)))))
(else (car stack)))))
```
---
**Selected commentary**
``(,foo ,@bar)` is the same as `(cons foo bar)` (i.e., it (effectively†) returns a new list with `foo` prepended to `bar`), except it's one character shorter if you compress all the spaces out.
Thus, you can read the iteration clauses as `(loop (cons token stack))` and `(loop (cons ((cadr ass) (cadr stack) (car stack)) (cddr stack)))` if that's easier on your eyes.
``((+ ,+) (- ,-) (* ,*) (/ ,/))` creates an association list with the *symbol* `+` paired with the *procedure* `+`, and likewise with the other operators. Thus it's a simple symbol lookup table (bare words are `(read)` in as symbols, which is why no further processing on `token` is necessary). Association lists have O(n) lookup, and thus are only suitable for short lists, as is the case here. :-P
† This is not technically accurate, but, for non-Lisp programmers, it gets a right-enough idea across.
[Answer]
# MATLAB – 158, 147
```
C=strsplit(input('','s'));D=str2double(C);q=[];for i=1:numel(D),if isnan(D(i)),f=str2func(C{i});q=[f(q(2),q(1)) q(3:end)];else q=[D(i) q];end,end,q
```
(input is read from user input, output printed out).
---
Below is the code prettified and commented, it pretty much implements the [postfix algorithm](https://en.wikipedia.org/wiki/Reverse_Polish_notation#Postfix_algorithm) described (with the assumption that expressions are valid):
```
C = strsplit(input('','s')); % prompt user for input and split string by spaces
D = str2double(C); % convert to numbers, non-numeric are set to NaN
q = []; % initialize stack (array)
for i=1:numel(D) % for each value
if isnan(D(i)) % if it is an operator
f = str2func(C{i}); % convert op to a function
q = [f(q(2),q(1)) q(3:end)]; % pop top two values, apply op and push result
else
q = [D(i) q]; % else push value on stack
end
end
q % show result
```
---
## Bonus:
In the code above, we assume operators are always binary (`+`, `-`, `*`, `/`). We can generalize it by using `nargin(f)` to determine the number of arguments the operand/function requires, and pop the right amount of values from the stack accordingly, as in:
```
f = str2func(C{i});
n = nargin(f);
args = num2cell(q(n:-1:1));
q = [f(args{:}) q(n+1:end)];
```
That way we can evaluate expressions like:
```
str = '6 5 1 2 mean_of_three 1 + 4 * +'
```
where `mean_of_three` is a user-defined function with three inputs:
```
function d = mean_of_three(a,b,c)
d = (a+b+c)/3;
end
```
[Answer]
## c -- 424 necessary character
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define O(X) g=o();g=o() X g;u(g);break;
char*p=NULL,*b;size_t a,n=0;float g,s[99];float o(){return s[--n];};
void u(float v){s[n++]=v;};int main(){getdelim(&p,&a,EOF,stdin);for(;;){
b=strsep(&p," \n\t");if(3>p-b){if(*b>='0'&&*b<='9')goto n;switch(*b){case 0:
case EOF:printf("%f\n",o());return 0;case'+':O(+)case'-':O(-)case'*':O(*)
case'/':O(/)}}else n:u(atof(b));}}
```
Assumes that you have a new enough libc to include `getdelim` in stdio.h. The approach is straight ahead, the whole input is read into a buffer, then we tokenize with `strsep` and use length and initial character to determine the class of each. There is no protection against bad input. Feed it "+ - \* / + - ...", and it will happily pop stuff off the memory "below" the stack until it seg faults. All non-operators are interpreted as floats by `atof` which means zero value if they don't look like numbers.
**Readable and commented:**
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *p=NULL,*b;
size_t a,n=0;
float g,s[99];
float o(){ /* pOp */
//printf("\tpoping '%f'\n",s[n-1]);
return s[--n];
};
void u(float v){ /* pUsh */
//printf("\tpushing '%f'\n",v);
s[n++]=v;
};
int main(){
getdelim(&p,&a,EOF,stdin); /* get all the input */
for(;;){
b=strsep(&p," \n\t"); /* now *b though *(p-1) is a token and p
points at the rest of the input */
if(3>p-b){
if (*b>='0'&&*b<='9') goto n;
//printf("Got 1 char token '%c'\n",*b);
switch (*b) {
case 0:
case EOF: printf("%f\n",o()); return 0;
case '+': g=o(); g=o()+g; u(g); break;
case '-': g=o(); g=o()-g; u(g); break;
case '*': g=o(); g=o()*g; u(g); break;
case '/': g=o(); g=o()/g; u(g); break;
/* all other cases viciously ignored */
}
} else { n:
//printf("Got token '%s' (%f)\n",b,atof(b));
u(atof(b));
}
}
}
```
**Validation:**
```
$ gcc -c99 rpn_golf.c
$ wc rpn_golf.c
9 34 433 rpn_golf.c
$ echo -4 5 + | ./a.out
1.000000
$ echo 5 2 / | ./a.out
2.500000
$ echo 5 2.5 / | ./a.out
2.000000
```
Heh! Gotta quote anything with `*` in it...
```
$ echo "5 1 2 + 4 * 3 - +" | ./a.out
14.000000
$ echo "4 2 5 * + 1 3 2 * + /" | ./a.out
2.000000
```
and my own test case
```
$ echo "12 8 3 * 6 / - 2 + -20.5 " | ./a.out
-20.500000
```
[Answer]
## Haskell (155)
```
f#(a:b:c)=b`f`a:c
(s:_)![]=print s
s!("+":v)=(+)#s!v
s!("-":v)=(-)#s!v
s!("*":v)=(*)#s!v
s!("/":v)=(/)#s!v
s!(n:v)=(read n:s)!v
main=getLine>>=([]!).words
```
[Answer]
## Perl (134)
```
@a=split/\s/,<>;/\d/?push@s,$_:($x=pop@s,$y=pop@s,push@s,('+'eq$_?$x+$y:'-'eq$_?$y-$x:'*'eq$_?$x*$y:'/'eq$_?$y/$x:0))for@a;print pop@s
```
Next time, I'm going to use the recursive regexp thing.
Ungolfed:
```
@a = split /\s/, <>;
for (@a) {
/\d/
? (push @s, $_)
: ( $x = pop @s,
$y = pop @s,
push @s , ( '+' eq $_ ? $x + $y
: '-' eq $_ ? $y - $x
: '*' eq $_ ? $x * $y
: '/' eq $_ ? $y / $x
: 0 )
)
}
print(pop @s);
```
I though F# is my only dream programming language...
[Answer]
### Windows PowerShell, 152 ~~181~~ ~~192~~
In readable form, because by now it's only two lines with no chance of breaking them up:
```
$s=@()
switch -r(-split$input){
'\+' {$s[1]+=$s[0]}
'-' {$s[1]-=$s[0]}
'\*' {$s[1]*=$s[0]}
'/' {$s[1]/=$s[0]}
'-?[\d.]+' {$s=0,+$_+$s}
'.' {$s=$s[1..($s.count)]}}
$s
```
**2010-01-30 11:07** (192) – First attempt.
**2010-01-30 11:09** (170) – Turning the function into a scriptblock solves the scope issues. Just makes each invocation two bytes longer.
**2010-01-30 11:19** (188) – Didn't solve the scope issue, the test case just masked it. Removed the index from the final output and removed a superfluous line break, though. And changed double to `float`.
**2010-01-30 11:19** (181) – Can't even remember my own advice. Casting to a numeric type can be done in a single char.
**2010-01-30 11:39** (152) – Greatly reduced by using regex matching in the `switch`. Completely solves the previous scope issues with accessing the stack to pop it.
[Answer]
**[Racket](http://racket-lang.org) 131:**
```
(let l((s 0))(define t(read))(cond[(real? t)
(l`(,t,@s))][(memq t'(+ - * /))(l`(,((eval t)(cadr s)
(car s)),@(cddr s)))][0(car s)]))
```
Line breaks optional.
Based on Chris Jester-Young's solution for Scheme.
[Answer]
## Python, 166 characters
```
import os,operator as o
S=[]
for i in os.read(0,99).split():
try:S=[float(i)]+S
except:S=[{'+':o.add,'-':o.sub,'/':o.div,'*':o.mul}[i](S[1],S[0])]+S[2:]
print S[0]
```
[Answer]
# Python 3, 119 bytes
```
s=[]
for x in input().split():
try:s+=float(x),
except:o='-*+'.find(x);*s,a,b=s;s+=(a+b*~-o,a*b**o)[o%2],
print(s[0])
```
Input: `5 1 1 - -7 0 * + - 2 /`
Output: `2.5`
(You can find a 128-character Python 2 version in the edit history.)
[Answer]
# JavaScript (157)
This code assumes there are these two functions: readLine and print
```
a=readLine().split(/ +/g);s=[];for(i in a){v=a[i];if(isNaN(+v)){f=s.pop();p=s.pop();s.push([p+f,p-f,p*f,p/f]['+-*/'.indexOf(v)])}else{s.push(+v)}}print(s[0])
```
[Answer]
## Perl, 128
This isn't really competitive next to the other Perl answer, but explores a different (suboptimal) path.
```
perl -plE '@_=split" ";$_=$_[$i],/\d||
do{($a,$b)=splice@_,$i-=2,2;$_[$i--]=
"+"eq$_?$a+$b:"-"eq$_?$a-$b:"*"eq$_?
$a*$b:$a/$b;}while++$i<@_'
```
Characters counted as diff to a simple `perl -e ''` invocation.
[Answer]
# flex - 157
```
%{
float b[100],*s=b;
#define O(o) s--;*(s-1)=*(s-1)o*s;
%}
%%
-?[0-9.]+ *s++=strtof(yytext,0);
\+ O(+)
- O(-)
\* O(*)
\/ O(/)
\n printf("%g\n",*--s);
.
%%
```
If you aren't familiar, compile with `flex rpn.l && gcc -lfl lex.yy.c`
[Answer]
Python, 161 characters:
```
from operator import*;s=[];i=raw_input().split(' ')
q="*+-/";o=[mul,add,0,sub,0,div]
for c in i:
if c in q:s=[o[ord(c)-42](*s[1::-1])]+s
else:s=[float(c)]+s
print(s[0])
```
[Answer]
## PHP, ~~439~~ ~~265~~ ~~263~~ ~~262~~ ~~244~~ 240 characters
```
<? $c=fgets(STDIN);$a=array_values(array_filter(explode(" ",$c)));$s[]=0;foreach($a as$b){if(floatval($b)){$s[]=$b;continue;}$d=array_pop($s);$e=array_pop($s);$s[]=$b=="+"?$e+$d:($b=="-"?$e-$d:($b=="*"?$e*$d:($b=="/"?$e/$d:"")));}echo$s[1];
```
This code should work with stdin, though it is not tested with stdin.
It has been tested on all of the cases, the output (and code) for the last one is here:
<http://codepad.viper-7.com/fGbnv6>
**Ungolfed, ~~314~~ ~~330~~ 326 characters**
```
<?php
$c = fgets(STDIN);
$a = array_values(array_filter(explode(" ", $c)));
$s[] = 0;
foreach($a as $b){
if(floatval($b)){
$s[] = $b;
continue;
}
$d = array_pop($s);
$e = array_pop($s);
$s[] = $b == "+" ? $e + $d : ($b == "-" ? $e - $d : ($b == "*" ? $e * $d : ($b == "/" ? $e / $d :"")));
}
echo $s[1];
```
[Answer]
## Python, 130 characters
Would be 124 characters if we dropped `b and` (which some of the Python answers are missing). And it incorporates 42!
```
s=[]
for x in raw_input().split():
try:s=[float(x)]+s
except:b,a=s[:2];s[:2]=[[a*b,a+b,0,a-b,0,b and a/b][ord(x)-42]]
print s[0]
```
[Answer]
# Python 3, ~~126~~ 132 chars
```
s=[2,2]
for c in input().split():
a,b=s[:2]
try:s[:2]=[[a+b,b-a,a*b,a and b/a]["+-*/".index(c)]]
except:s=[float(c)]+s
print(s[0])
```
There have been better solutions already, but now that I had written it (without having read the prior submissions, of course - even though I have to admit that my code looks as if I had copypasted them together), I wanted to share it, too.
[Answer]
# C, 232 229 bytes
Fun with recursion.
```
#include <stdlib.h>
#define b *p>47|*(p+1)>47
char*p;float a(float m){float n=strtof(p,&p);b?n=a(n):0;for(;*++p==32;);m=*p%43?*p%45?*p%42?m/n:m*n:m-n:m+n;return*++p&&b?a(m):m;}main(c,v)char**v;{printf("%f\n",a(strtof(v[1],&p)));}
```
## Ungolfed:
```
#include <stdlib.h>
/* Detect if next char in buffer is a number */
#define b *p > 47 | *(p+1) > 47
char*p; /* the buffer */
float a(float m)
{
float n = strtof(p, &p); /* parse the next number */
/* if the next thing is another number, recursively evaluate */
b ? n = a(n) : 0;
for(;*++p==32;); /* skip spaces */
/* Perform the arithmetic operation */
m = *p%'+' ? *p%'-' ? *p%'*' ? m/n : m*n : m-n : m+n;
/* If there's more stuff, recursively parse that, otherwise return the current computed value */
return *++p && b ? a(m) : m;
}
int main(int c, char **v)
{
printf("%f\n", a(strtof(v[1], &p)));
}
```
## Test Cases:
```
$ ./a.out "-4 5 +"
1.000000
$ ./a.out "5 2 /"
2.500000
$ ./a.out "5 2.5 /"
2.000000
$ ./a.out "5 1 2 + 4 * 3 - +"
14.000000
$ ./a.out "4 2 5 * + 1 3 2 * + /"
2.000000
```
[Answer]
# JavaScript ES7, 119 bytes
I'm getting a bug with array comprehensions so I've used `.map`
```
(s,t=[])=>(s.split` `.map(i=>+i?t.unshift(+i):t.unshift((r=t.pop(),o=t.pop(),[r+o,r-o,r*o,r/o]['+-*/'.indexOf(i)]))),t)
```
[Try it online at ESFiddle](http://server.vihan.ml/p/esfiddle/?code=f%3D(s%2Ct%3D%5B%5D)%3D%3E(s.split%60%20%60.map(i%3D%3E%2Bi%3Ft.unshift(%2Bi)%3At.unshift((r%3Dt.pop()%2Co%3Dt.pop()%2C%5Br%2Bo%2Cr-o%2Cr*o%2Cr%2Fo%5D%5B'%2B-*%2F'.indexOf(i)%5D)))%2Ct)%3B%0A%0Af(%2211%203%20%2B%22))
[Answer]
# C 153
Sometimes a program can be made a bit shorter with more golfing and sometimes you just take completely the wrong route and the much better version is found by someone else.
**Thanks to @ceilingcat for finding a much better (and shorter) version**
```
double atof(),s[99],*p=s;y,z;main(c,v)char**v;{for(;--c;*p=z?z-2?~z?z-4?p+=2,atof(*v):*p/y:*p*y:*p-y:*p+y)z=1[*++v]?9:**v-43,y=*p--;printf("%f\n",s[1]);}
```
[Try it online!](https://tio.run/##HY7RCoIwGIVfJYRg@7chml3oGHsQ88JWK6F0qA1m1Kv/bd1858A5HI4RN2MQL9Pr/Lju@nWyhPKlreuOg1OLDHyTz34YieGemns/A3j5ttNMpBBGxs6mN1Hqb5JKO6ZK/l8BTxtweYiABJHAAt1U0QJjvtN1E7dEdeBBxVhINw/jakm2t6cxix@KjsoPIlZY4hEBGRZ4iD65/Ac "C (gcc) – Try It Online")
My original version:
```
#include <stdlib.h>
#define O(x):--d;s[d]=s[d]x s[d+1];break;
float s[99];main(c,v)char**v;{for(int i=1,d=0;i<c;i++)switch(!v[i][1]?*v[i]:' '){case'+'O(+)case'-'O(-)case'*'O(*)case'/'O(/)default:s[++d]=atof(v[i]);}printf("%f\n",s[1]);}
```
If you are compiling it with mingw32 you need to turn off globbing (see <https://www.cygwin.com/ml/cygwin/1999-11/msg00052.html>) by compiling like this:
```
gcc -std=c99 x.c C:\Applications\mingw32\i686-w64-mingw32\lib\CRT_noglob.o
```
If you don't \* is automatically expanded by the mingw32 CRT into filenames.
[Answer]
## PHP - 259 characters
```
$n=explode(" ",$_POST["i"]);$s=array();for($i=0;$i<count($n);$s=$d-->0?array_merge($s,!$p?array($b,$a,$c):array($p)):$s){if($c=$n[$i++]){$d=1;$a=array_pop($s);$b=array_pop($s);$p=$c=="+"?$b+$a:($c=="-"?$b-$a:($c=="*"?$b*$a:($c=="/"?$b/$a:false)));}}echo$s[2];
```
Assuming input in POST variable *i*.
[Answer]
## C# - 392 characters
```
namespace System.Collections.Generic{class P{static void Main(){var i=Console.ReadLine().Split(' ');var k=new Stack<float>();float o;foreach(var s in i)switch (s){case "+":k.Push(k.Pop()+k.Pop());break;case "-":o=k.Pop();k.Push(k.Pop()-o);break;case "*":k.Push(k.Pop()*k.Pop());break;case "/":o=k.Pop();k.Push(k.Pop()/o);break;default:k.Push(float.Parse(s));break;}Console.Write(k.Pop());}}}
```
However, if arguments can be used instead of standard input, we can bring it down to
## C# - 366 characters
```
namespace System.Collections.Generic{class P{static void Main(string[] i){var k=new Stack<float>();float o;foreach(var s in i)switch (s){case "+":k.Push(k.Pop()+k.Pop());break;case "-":o=k.Pop();k.Push(k.Pop()-o);break;case "*":k.Push(k.Pop()*k.Pop());break;case "/":o=k.Pop();k.Push(k.Pop()/o);break;default:k.Push(float.Parse(s));break;}Console.Write(k.Pop());}}}
```
[Answer]
### Scala 412 376 349 335 312:
```
object P extends App{
def p(t:List[String],u:List[Double]):Double={
def a=u drop 2
t match{
case Nil=>u.head
case x::y=>x match{
case"+"=>p(y,u(1)+u(0)::a)
case"-"=>p(y,u(1)-u(0)::a)
case"*"=>p(y,u(1)*u(0)::a)
case"/"=>p(y,u(1)/u(0)::a)
case d=>p(y,d.toDouble::u)}}}
println(p((readLine()split " ").toList,Nil))}
```
[Answer]
# Python - 206
```
import sys;i=sys.argv[1].split();s=[];a=s.append;b=s.pop
for t in i:
if t=="+":a(b()+b())
elif t=="-":m=b();a(b()-m)
elif t=="*":a(b()*b())
elif t=="/":m=b();a(b()/m)
else:a(float(t))
print(b())
```
Ungolfed version:
```
# RPN
import sys
input = sys.argv[1].split()
stack = []
# Eval postfix notation
for tkn in input:
if tkn == "+":
stack.append(stack.pop() + stack.pop())
elif tkn == "-":
tmp = stack.pop()
stack.append(stack.pop() - tmp)
elif tkn == "*":
stack.append(stack.pop() * stack.pop())
elif tkn == "/":
tmp = stack.pop()
stack.append(stack.pop()/tmp)
else:
stack.append(float(tkn))
print(stack.pop())
```
Input from command-line argument; output on standard output.
[Answer]
# ECMAScript 6 (131)
Just typed together in a few seconds, so it can probably be golfed further or maybe even approached better. I might revisit it tomorrow:
```
f=s=>(p=[],s.split(/\s+/).forEach(t=>+t==t?p.push(t):(b=+p.pop(),a=+p.pop(),p.push(t=='+'?a+b:t=='-'?a-b:t=='*'?a*b:a/b))),p.pop())
```
[Answer]
## C# - 323 284 241
```
class P{static void Main(string[] i){int x=0;var a=new float[i.Length];foreach(var s in i){var o="+-*/".IndexOf(s);if(o>-1){float y=a[--x],z=a[--x];a[x++]=o>3?z/y:o>2?z*y:o>1?z-y:y+z;}else a[x++]=float.Parse(s);}System.Console.Write(a[0]);}}
```
Edit: Replacing the Stack with an Array is way shorter
Edit2: Replaced the ifs with a ternary expression
[Answer]
# Python 2
I've tried out some different approaches to the ones published so far. None of these is quite as short as the best Python solutions, but they might still be interesting to some of you.
## Using recursion, 146
```
def f(s):
try:x=s.pop();r=float(x)
except:b,s=f(s);a,s=f(s);r=[a+b,a-b,a*b,b and a/b]['+-*'.find(x)]
return r,s
print f(raw_input().split())[0]
```
## Using list manipulation, 149
```
s=raw_input().split()
i=0
while s[1:]:
o='+-*/'.find(s[i])
if~o:i-=2;a,b=map(float,s[i:i+2]);s[i:i+3]=[[a+b,a-b,a*b,b and a/b][o]]
i+=1
print s[0]
```
## Using `reduce()`, 145
```
print reduce(lambda s,x:x in'+-*/'and[(lambda b,a:[a+b,a-b,a*b,b and a/b])(*s[:2])['+-*'.find(x)]]+s[2:]or[float(x)]+s,raw_input().split(),[])[0]
```
[Answer]
## Matlab, 228
```
F='+-/*';f={@plus,@minus,@rdivide,@times};t=strsplit(input('','s'),' ');i=str2double(t);j=~isnan(i);t(j)=num2cell(i(j));while numel(t)>1
n=find(cellfun(@(x)isstr(x),t),1);t{n}=bsxfun(f{t{n}==F},t{n-2:n-1});t(n-2:n-1)=[];end
t{1}
```
Ungolfed:
```
F = '+-/*'; %// possible operators
f = {@plus,@minus,@rdivide,@times}; %// to be used with bsxfun
t = strsplit(input('','s'),' '); %// input string and split by one or multiple spaces
i = str2double(t); %// convert each split string to number
j =~ isnan(i); %// these were operators, not numbers ...
t(j) = num2cell(i(j)); %// ... so restore them
while numel(t)>1
n = find(cellfun(@(x)isstr(x),t),1); %// find left-most operator
t{n} = bsxfun(f{t{n}==F}, t{n-2:n-1}); %// apply it to preceding numbers and replace
t(n-2:n-1)=[]; %// remove used numbers
end
t{1} %// display result
```
[Answer]
# K5, 70 bytes
```
`0:*{$[-9=@*x;((*(+;-;*;%)@"+-*/"?y).-2#x;x,.y)@47<y;(.x;.y)]}/" "\0:`
```
I'm not sure when K5 was released, so this *might* not count. Still awesome!
] |
[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/81069/edit).
Closed 7 years ago.
[Improve this question](/posts/81069/edit)
Cosmic rays are [bad for computers](//stackoverflow.com/q/2580933/5223757). They corrupt RAM, and that causes problems. Computer chips are shrinking, and that makes them [more vulnerable](//stackoverflow.com/q/2580933/5223757#comment2588767_2580963) to the cosmic rays. We will not give in to these high-energy particles. Turing-completeness shall live on!
## Task
Your task is to write a Turing machine. But not just any Turing machine: your Turing machine has to be cosmic ray-proof! At any time in your program's execution, exactly one bit will be flipped in its memory-space. Your program must continue executing normally regardless.
Your Turing machine must have an arbitrarily-sized tape (in both directions), initialised to `NUL` (`0`).
### Input
The input will be a list of tuples, each conforming to the following format:
```
state value new-value direction new-state
```
The items of each tuple are as follows:
* `state`, `new-state`: States are strings of arbitrary length. In practice they won't be very long. A blank space will not be used in a state name.
* `value`, `new-value`: Each value is exactly one byte. It may be any character from `NUL` to `DEL`.
* `direction`: The direction to move. Can be `l` (left), `r` (right) or `n` (stay still).
### Output
Output should be the blocks of tape that have been written to, from left to right.
## Scoring
Your program will be scored by `number of errors / number of rays`. Cosmic rays are simulated by randomly changing one bit in the program's working memory whilst it is running. Only one ray will hit the program per execution. Lowest score wins.
Your program must run without cosmic rays hitting it.
## Cosmic Ray algorithm
```
prog = debug.run("program");
for (states = 0; !prog.exited; states++) {
prog.step(1);
}
output = prog.output;
raystate = randint(0, states); // [0 - states)
prog = debug.run("program");
prog.step(raystate);
addr = prog.memory.randaddress();
bit = randint(0, 8); // [0 - 8)
addr.flipbit(bit);
prog.run();
if (output != prog.output) {
print("Failed");
} else {
print("Succeded");
}
```
]
|
[Question]
[
The [PBM (Portable BitMap) format](http://en.wikipedia.org/wiki/Netpbm_format#PBM_example) is a very simple ASCII black and white bitmap format.
Here's an example for the letter 'J' (copy-pasted from the wikipedia link):
```
P1
# This is an example bitmap of the letter "J"
6 10
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
1 0 0 0 1 0
0 1 1 1 0 0
0 0 0 0 0 0
0 0 0 0 0 0
```
It's time we build a small tool to generate files in this nifty little format!
Your **goal** is to write the shortest program (in any language) that conforms to the following rules:
1. Your program takes one string from stdin (for example `CODEGOLF.STACKEXCHANGE.COM!`)
2. It generates a PBM file with a bitmapped (readable) representation of the string.
3. Each character is constructed as a 8x8 grid.
4. You must support the characters [A-Z] (all uppercase), space, a point ('.') and an exclamation mark ('!').
5. No external libraries allowed (certainly no PBM related ones)!
6. The used character set must not simply be external to your program. Part of the challenge is storing the characters efficiently...
Testing for validness of the PBM format can be done with the GIMP (or others). Do show off sample input and output!
**The shortest solution will be awarded the answer points on 2012-01-31.**
Have fun golfing!
PS: I've added a bounty (percentage-wise a huge part of my codegolf reputation) to (hopefully) draw in more competitors.
[Answer]
## Perl, 164 bytes, no zlib/gzip compression
After sleeping on the problem, I managed to figure out a much shorter solution than my first one. The trick is to take advantage of a minor loophole in the rules: the characters need to fit in 8 by 8 pixels each, but nothing says they have to *fill* all that space. So I drew my own 4 by 5 pixel font, allowing me to pack two characters into 5 bytes.
The output looks like this:
 (scaled x 4)
 (original size)
Before giving the actual code with the embedded font data, let me show a de-golfed version:
```
y/A-Z!./\0-\033/ for @a = <> =~ /./g;
say "P4 " . 8*@a . " 8";
for $p (qw'PACKED FONT DATA') {
print chr vec $p, ord, 4 for @a;
}
```
In the actual code, the `PACKED FONT DATA` is replaced by a binary string consisting of eight whitespace-delimited rows (four 14-byte rows and one 13-byte one, plus three single null bytes for the blank rows). I deliberately designed my font so that the packed data contains no whitespace, single quotes or backslashes, so that it could be encoded in `qw'...'`.
Since the packed font string contains unprintable characters, I've provided the actual script as a hex dump. Use `xxd -r` to turn it back into executable Perl code:
```
0000000: 792f 412d 5a21 2e2f 002d 1b2f 666f 7240 y/A-Z!./.-./for@
0000010: 613d 3c3e 3d7e 2f2e 2f67 3b73 6179 2250 a=<>=~/./g;say"P
0000020: 3420 222e 382a 4061 2e22 2038 223b 666f 4 ".8*@a." 8";fo
0000030: 7224 7028 7177 2700 20e6 e6ff 9612 8999 r$p(qw'. .......
0000040: e6e6 7759 99f5 0420 9999 8898 128a df99 ..wY... ........
0000050: 9928 5999 1504 20ef 98ee fb12 8cb9 e9e9 .(Y... .........
0000060: 2659 6965 0420 9999 8899 928a 9989 ab21 &Yie. .........!
0000070: 599f 8220 e9e6 8f96 62f9 9986 972e 2699 Y.. ....b.....&.
0000080: f284 2000 2000 2729 7b70 7269 6e74 2063 .. . .'){print c
0000090: 6872 2076 6563 2470 2c6f 7264 2c34 666f hr vec$p,ord,4fo
00000a0: 7240 617d r@a}
```
**Here's how it works:**
* The first line (in the de-golfed version) reads a single line of input, splits it into an array of characters (conveniently omitting any trailing newlines) and maps the letters `A` to `Z` and the characters `!` and `.` to the character codes 0 to 28, which normally correspond to unprintable control characters in ASCII / Unicode. (A minor side effect of this is that any tabs in the input get printed as `J`s.) The space character is left unmapped, since the output loop turns any codes above 28 into blanks anyway.
* The second line just prints the PBM header. It uses the Perl 5.10 `say` feature, so you need to run this script with `perl -M5.010` for it to work.
* The output loop takes a whitespace-delimited list of packed image rows and assigns each of them into `$p` in turn. (I designed the font so that the packed data wouldn't contain any whitespace or `'` characters.) It then loops over the input characters in `@a`, using Perl's `vec` command to extract the 4-bit nibble corresponding to the mapped character code from the image row, pads it to an 8-bit byte and prints it.
---
### Old answer, 268 bytes:
This is a quick and dirty first attempt. I stole PleaseStand's font and compressed it along with my source code. Since the resulting script is mostly unprintable, here's a hexdump; use `xxd -r` to turn it into executable Perl code:
```
0000000: 7573 6520 436f 6d70 7265 7373 275a 6c69 use Compress'Zli
0000010: 623b 6576 616c 2075 6e63 6f6d 7072 6573 b;eval uncompres
0000020: 7320 2778 da85 d03d 4b03 4118 85d1 452c s 'x...=K.A...E,
0000030: b69c 72cb 7519 4894 552c 2c02 3319 ee5c ..r.u.H.U,,.3..\
0000040: d7b8 5a89 6093 4634 7e82 c490 6c91 8597 ..Z.`.F4~...l...
0000050: 80fe 7267 d660 23ae e52d 0e0f dcd6 f8c3 ..rg.`#..-......
0000060: e9d1 5e6e ccec a15c ddb5 c5d5 495e 94a3 ..^n...\....I^..
0000070: 83b7 c7f9 73f3 5216 f9a8 787a 5fea 666c ....s.R...xz_.fl
0000080: 9dd1 b763 dd98 76f8 2df6 0799 5811 7144 ...c..v.-...X.qD
0000090: 4acc ee9d b8b0 c90f 7e4a 8264 6016 cbd7 J.......~J.d`...
00000a0: 79f3 1b91 047c 4055 409e 9e54 1dda ed41 y....|@[[email protected]](/cdn-cgi/l/email-protection)
00000b0: 9a20 8080 6adc 5c47 8488 7495 f621 01d7 . ..j.\G..t..!..
00000c0: 6b6c 902e b6c8 2a6a 6643 f56f e99c 115d kl....*jfC.o...]
00000d0: 5c7a f1b2 13d0 3453 790f da74 c813 751d \z....4Sy..t..u.
00000e0: 11ce d821 ad90 247f 2292 5b54 c14f 3c4e ...!..$.".[T.O<N
00000f0: 49c5 4c53 a1a7 c478 391c 714c f113 0747 I.LS...x9.qL...G
0000100: ab6c 4482 9fd2 177a 5677 6327 .lD....zVwc'
```
The decompressed Perl code consists of the following preamble:
```
y;A-Z.! ;;cd,say"P4 ",8*length," 8"for$t=<>
```
followed by eight repetitions of the following code:
```
;$_=$t;y(A-Z.! )'BITMAP DATA HERE';print
```
with `BITMAP DATA HERE` replaced with 29 bytes encoding one row of the font.
[Answer]
## GolfScript, 133 bytes
This is based on [my 164-byte Perl solution](https://codegolf.stackexchange.com/a/4682/3191) and uses the same nibble-packed 4 by 5 pixel font. Again, I'll give the readable version first:
```
{91,65>"!. "+?}%:s"P4"\,8*8'FONT DATA HERE'{16base}%[3]/{:p;{[p=0]0=}s%}%]n*
```
Here, `FONT DATA HERE` stands for 71 bytes of binary packed font data. The encoding is slightly different than in the Perl version: instead of splitting the packed string on whitespace, I expand it first and then split it on the nibble `3` (chosen because it just happens not to occur anywhere in the font).
Since the font data in the actual script contains unprintable characters, I give it as a hex dump below. Use `xxd -r` to turn the hex dump back into executable GolfScript code:
```
0000000: 7b39 312c 3635 3e22 212e 2022 2b3f 7d25 {91,65>"!. "+?}%
0000010: 3a73 2250 3422 5c2c 382a 3827 36e6 eff6 :s"P4"\,8*8'6...
0000020: 9219 8996 e6e7 7959 95f4 3999 9888 921a ......yY..9.....
0000030: 8fd9 9998 2959 9514 3fe8 9eeb f21c 89b9 ....)Y..?.......
0000040: e9e6 2959 6564 3999 9889 929a 8999 8ba1 ..)Yed9.........
0000050: 295f 9283 9e6e f869 269f 9968 79e2 6299 )_...n.i&..hy.b.
0000060: 2f48 3327 7b31 3662 6173 657d 255b 335d /H3'{16base}%[3]
0000070: 2f7b 3a70 3b7b 5b70 3d30 5d30 3d7d 7325 /{:p;{[p=0]0=}s%
0000080: 7d25 5d6e 2a }%]n*
```
Unlike the Perl script, this code prints any characters outside the set `A`–`Z`, `!`, `.`, `space` as funny-looking little squiggles. Replacing the squiggles with blanks would cost 2 extra chars; removing them entirely would cost 4.
This is my first GolfScript program ever, so I wouldn't be surprised if there's some room left for optimization. Here's how it works:
* `{91,65>"!. "+?}%:s` maps the valid input characters (`A`–`Z`, `!`, `.`, `space`) to the numbers 0 – 28 and assigns the result to `s`. Any characters outside the valid set get mapped to -1, which is what produces the squiggles when printed.
* `"P4"\,8*8` pushes the values "P4", 8 times the length of the input, and 8 onto the stack. When printed at the end, these will form the PBM header.
* `{16base}%[3]/` takes the preceding string of font data, splits each byte of it into two nibbles, and splits the result into blocks delimited by the value `3`. `{:p;{[p=0]0=}s%}%` then loops over these blocks, first assigning each block to the variable `p` and then looping over the remapped input string `s`, replacing each character with the value at the corresponding offset in `p`. The funny-looking construct `[p=0]0=` does the same as `p=`, except that it returns 0 for any offsets past the end of `p`; I don't really like it, but I haven't been able to figure out any shorter way to handle that.
* Finally, `]n*` takes everything on the stack (the three header values and the image data array) and joins them together with newlines for printing.
[Answer]
**8086 Machine Code**
190 Bytes (122 Bytes using BIOS)
Here's Base64 encoded WinXP/MSDos .COM file:
```
M8COwCaKDoUEitEmxD4MAaCAAP7IfliK8MHgA7cK9ve9egEAZ
vy0APb3AUb6iMi0APb3AUb+x0YACg2DxQK+ggCK7qz24YvYJo
ohswjQ5LAwFACIRgBF/st18v7NdeRH/sp10sZGACS6cAG0Cc0
hw1AxCg0wMDAgMDA=
```
(Use something [like this](http://www.opinionatedgeek.com/DotNet/Tools/Base64Decode/default.aspx)) to decode the text and save as "pbm.com". Then, at the command prompt, type:
>
> pbm text to encode>outputfilename.pbm
>
>
>
I've tested this on my WinXP machine using both the standard command prompt and DosBox V0.74.
**UPDATE**
This version is 190 bytes and uses Ilmari Karonen's tiny font (no bios access here!):-
```
voAArf7Iflq7YwG/vgG6Cg20Bfbk9vIAZfsy5PbyAUX5Vqw48HQoLEFzCDQG/sAMGSQfM8
nQ6NfA0QPS6IjEsQSwJtDsENCq4vewMKrr04DDEF6A+7N1ycYFJLqzAbQJzSHDdnb/loIZ
mXZ2flmZ9QAAIJmZEZGCFb+ZmSFZmYUPDy9/kXf9ghPZeXkmWWllAAAgmZkRmZIVmRldKF
mfEgAAAHl2H5Zi+ZkWnicmmfIAICBQMQoNMDAwIDUKDQ==
```
[Answer]
## Shell script (code+data = 295 chars)
I hope tail, gzip, and dd do not count as "external libraries." Run as `echo -n 'YOUR TEXT HERE' | ./text.sh > out.pbm`. The font I used is Small Fonts size 7.5, although I did have to clip the descender off the Q.
### Example output
### Code (137 chars)
```
i=`od -tu1|cut -c9-`
echo P4
for a in {0..7}
do for b in $i
do tail -2 $0|zcat|dd bs=1 count=1 skip=$((8*b+a))
done
done>8
wc -c 8
cat 8
```
### Complete script
(use `xxd -r` to recreate original file)
```
0000000: 693d 606f 6420 2d74 7531 7c63 7574 202d i=`od -tu1|cut -
0000010: 6339 2d60 0a65 6368 6f20 5034 0a66 6f72 c9-`.echo P4.for
0000020: 2061 2069 6e20 7b30 2e2e 377d 0a64 6f20 a in {0..7}.do
0000030: 666f 7220 6220 696e 2024 690a 646f 2074 for b in $i.do t
0000040: 6169 6c20 2d32 2024 307c 7a63 6174 7c64 ail -2 $0|zcat|d
0000050: 6420 6273 3d31 2063 6f75 6e74 3d31 2073 d bs=1 count=1 s
0000060: 6b69 703d 2428 2838 2a62 2b61 2929 0a64 kip=$((8*b+a)).d
0000070: 6f6e 650a 646f 6e65 3e38 0a77 6320 2d63 one.done>8.wc -c
0000080: 2038 0a63 6174 2038 0a1f 8b08 0000 0000 8.cat 8........
0000090: 0000 ffed cdb1 0a83 3014 8561 910e 8e8e ........0..a....
00000a0: 193b dca1 631f 2084 9353 6ba3 a3e0 e2a8 .;..c. ..Sk.....
00000b0: 2fe0 d8e1 22d8 276f 9a50 e813 940e fdb8 /...".'o.P......
00000c0: 70f9 a753 247f 7829 f0b5 b9e2 c718 2322 p..S$.x)......#"
00000d0: 1ba9 e9a8 9688 6895 892a 7007 f0fe 701e ......h..*p...p.
00000e0: b879 ef48 6e8c aa4f 219c d984 750d 0d91 .y.Hn..O!...u...
00000f0: e9b2 8c63 d779 3fcf c3d0 f76d eb7c e2d2 ...c.y?....m.|..
0000100: 1880 d4d7 4b6e 9296 b065 49ab 75c6 cc92 ....Kn...eI.u...
0000110: 1411 63f6 7de7 3489 9031 847c 3c9a 531d ..c.}.4..1.|<.S.
0000120: e9a1 aa8f 803e 01 .....>.
```
### Explanation
* `od` is the standard "octal dump" utility program. The `-tu1` option tells it to produce a decimal dump of individual bytes instead (a sufficient workaround for bash's lack of asc(), ord(), .charCodeAt(), etc.)
* `P4` is the magic number for a binary format PBM file, which packs eight pixels into each byte (versus `P1` for the ASCII format PBM file). You will see how this proves useful.
* Per row of final output, the program pulls an eight-pixel byte (corresponding to the ASCII code and line number) from the gzip-compressed data section at the end using `dd`. (`tail -2 $0` extracts the script's last two lines; the compressed data includes one 0x0a linefeed byte.) It so happens that eight pixels is the width of a single character. The null bytes that fill the gaps between supported characters are easily compressible because they are all the same.
* All this is written to a file named "8". Because there are exactly eight rows (and also eight pixels per byte), the number of bytes is the width of the output in pixels. The output's height is also included in that `wc -c` prints the input filename "8" after its byte count.
* Now that the header is complete, the image data is printed. Bash only notices that the last two lines are not valid commands (the last one actually invalid UTF-8) after it has executed everything coming before.
* I used KZIP only to compress the data section, [as Ilmari Karonen did](https://codegolf.stackexchange.com/a/4196/163) for an *entire submission* to the 12 Days of Christmas challenge. As described there, it is essentially necessary to use a hex editor to replace the ZIP header format with a gzip header. Including the CRC-32 and file size from the original ZIP header seems to be unnecessary.
[Answer]
# Python 2, ~~248~~ 247 bytes
```
s=raw_input();k=len(s);print"P1",k*8,8
for i in range(k*24):a=s[i/3%k];j=max(".!".find(a)+1,ord(a)-62)*3;print int("00080084IMVAENBSIFERBSUF4UFQQEMVDT4NAP4MNDSI9MRTMRBARA4NBQRAMNBE4E94NURDARDNRDMLD95DSL7"[j:j+3],32)>>(i/3/k*3+i%3)&1," 0"*(i%3/2*5)
```
Uses a 3x5 font, packed into a printable string, 3 bytes per character. The font is clearly legible, although the n is lowercase and the v might be mistaken for a u if it isn't seen in context.
Actual Size:
[](https://i.stack.imgur.com/n74EH.png)
Zoomed x3:
[](https://i.stack.imgur.com/kS94M.png)
The output is a P1 type PBM, as per the example in the challenge. It was a fun challenge.
[Answer]
## Ruby 1.9, 346 bytes (122 code + 224 bytes data)
Here is the result:
(It's nice, isn't it?)
```
z=0..7;puts"P1\n#{(s=gets).size*8} 8",z.map{|i|s.bytes.flat_map{|o|z.map{|j|'DATA'.unpack('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}
```
The font was generated by `figlet -f banner -w 1000 $LETTERS` and [this script](https://gist.github.com/3cda65f5513ee48774f9).
Run with `echo -n 'CODEGOLF.STACKEXCHANGE.COM!' | ruby script.rb > image.pbm`.
The script generate all the rows and simply print them.
Here is an hexdump (use `xxd -r`):
```
0000000: 7a3d 302e 2e37 3b70 7574 7322 5031 5c6e z=0..7;puts"P1\n
0000010: 237b 2873 3d67 6574 7329 2e73 697a 652a #{(s=gets).size*
0000020: 387d 2038 222c 7a2e 6d61 707b 7c69 7c73 8} 8",z.map{|i|s
0000030: 2e62 7974 6573 2e66 6c61 745f 6d61 707b .bytes.flat_map{
0000040: 7c6f 7c7a 2e6d 6170 7b7c 6a7c 271c 1c1c |o|z.map{|j|'...
0000050: 0800 1c1c 0000 0000 001c 1c1c 0008 1422 ..............."
0000060: 417f 4141 003f 4141 3f41 413f 003e 4101 A.AA.?AA?AA?.>A.
0000070: 0101 413e 003f 4141 4141 413f 007f 0101 ..A>.?AAAAA?....
0000080: 1f01 017f 007f 0101 1f01 0101 003e 4101 .............>A.
0000090: 7941 413e 0041 4141 7f41 4141 001c 0808 yAA>.AAA.AAA....
00000a0: 0808 081c 0040 4040 4041 413e 0042 2212 .....@@@@AA>.B".
00000b0: 0e12 2242 0001 0101 0101 017f 0041 6355 .."B.........AcU
00000c0: 4941 4141 0041 4345 4951 6141 007f 4141 IAAA.ACEIQaA..AA
00000d0: 4141 417f 003f 4141 3f01 0101 003e 4141 AAA..?AA?....>AA
00000e0: 4151 215e 003f 4141 3f11 2141 003e 4101 AQ!^.?AA?.!A.>A.
00000f0: 3e40 413e 007f 0808 0808 0808 0041 4141 >@A>.........AAA
0000100: 4141 413e 0041 4141 4122 1408 0041 4949 AAA>.AAAA"...AII
0000110: 4949 4936 0041 2214 0814 2241 0041 2214 III6.A"..."A.A".
0000120: 0808 0808 007f 2010 0804 027f 0027 2e75 ...... ......'.u
0000130: 6e70 6163 6b28 2751 3c2a 2729 5b6f 3e36 npack('Q<*')[o>6
0000140: 343f 6f2d 3633 3a6f 2f34 365d 5b69 2a38 4?o-63:o/46][i*8
0000150: 2b6a 5d7d 7d2a 2720 277d +j]}}*' '}
```
It takes 93 bytes of code when using goruby:
```
ps"P1\n#{(s=gt).sz*8} 8",8.mp{|i|s.y.fl{|o|8.mp{|j|'DATA'.ua('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}
```
Using ZLib trim the data size to 142 bytes instead of 224, but adds 43 bytes in the code, so 307 bytes:
```
#coding:binary
require'zlib';z=0..7;puts"P1\n#{(s=gets).size*8} 8",z.map{|i|s.bytes.flat_map{|o|z.map{|j|Zlib.inflate("DATA").unpack('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}
```
Which gives a total of 268 when using goruby:
```
#coding:binary
rq'zlib';ps"P1\n#{(s=gt).sz*8} 8",8.mp{|i|s.y.fl{|o|8.mp{|j|Zlib.if("DATA").ua('Q<*')[o>64?o-63:o/46][i*8+j]}}*' '}
```
[Answer]
### Java 862 826:
Here is a different approach. I think 'awt' does not count as external lib.
```
import java.awt.*;
class B extends Frame{String s="ABCDEFGHIJKLMNOPQRSTUVWXYZ .!";int l=29;static Robot r;int[][][]m=new int[l][8][8];
public void paint(Graphics g){for(int y=0;y<8;++y){int py=(y<3)?y:y+1;for(int a=0;a<l;++a)
for(int x=0;x<8;++x)
m[a][x][y]=(r.getPixelColor(8*a+x+17+x/4,py+81)).getRGB()<-1?1:0;}
System.out.println("P1\n"+(getTitle().length()*8)+" 8");
for(int y=0;y<8;++y){for(char c:getTitle().toCharArray()){int a=s.indexOf(c);
for(int x=0;x<8;++x)System.out.print(m[a][x][y]);}
System.out.println();}
System.exit(0);}
public B(String p){super(p);
setBackground(Color.WHITE);
setSize(400,60);
Label l=new Label(s);
l.setFont(new Font("Monospaced",Font.PLAIN,13));
add(l);
setLocation(9,49);
setVisible(true);}
public static void main(String a[])throws Exception{r=new Robot();
new B(a[0]);}}
```
And ungolfed:
```
import java.awt.*;
class PBM extends Frame
{
String s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ .!";
int l=29;
Robot robot;
int[][][] map = new int[l][8][8];
static boolean init = false;
public void paint (Graphics g)
{
for (int y = 0; y < 8; ++y)
{
int py = (y < 3) ? y : y +1;
for (int a = 0; a < l; ++a)
{
for (int x = 0; x < 8; ++x)
{
map[a][x][y] = (robot.getPixelColor (8*a+x+17+x/4, py+81)).getRGB () < -1 ? 1 : 0;
}
}
}
System.out.println("P1\n"+(getTitle().length()*8)+" 8");
for (int y = 0; y < 8; ++y) {
for (char c : getTitle ().toCharArray ()) {
int a = s.indexOf (c);
for (int x = 0; x < 8; ++x) {
System.out.print (map[a][x][y]);
}
}
System.out.println ();
}
System.exit (0);
}
public PBM (String p) throws Exception
{
super (p);
robot = new Robot ();
setBackground (Color.WHITE);
setSize (400, 60);
Label l=new Label(s);
l.setFont (new Font ("Monospaced", Font.PLAIN, 13));
add(l);
setLocation (9,49);
setVisible (true);
}
public static void main (String args[]) throws Exception
{
new PBM (args[0]);
}
}
```
Robot is the somehow curious way of Java to call getPixel. I create a Label with the alphabet, and measure where a pixel is for each letter.
In the paint method, `int py = (y < 3) ? y : y +1;` and `(8*a+x+17+x/4, py+81)` is the complicated way, to adjust the position in the font. Huuuh! else it would need 9 lines, and every 4th letter, there is an additional pixel horizontally. Trial and error brought me to this solution.
Then the header of the PBM is written, and each line of the message. The message is passed as title of the frame.
That's it. Not the shortest code, but no manual font painting was necessary.
Maybe it could be shorter in BeanShell or Scala.
And now - how does it look like?
```
java B "JAVA.CAFE BABE" > jcb.pbm
```
Multiple zooms applied: 
Unzoomed: 
Not that the number of chars is the number of chars from the Perl solution shuffled.
(golfed a little bit more. Made Robot static, which avoids one Exception declaration.)
[Answer]
# C++ TOO LARGE TO WIN
I wrote a full featured PPM drawing program in C++, with my own bitmapped font. Even stripping out all non necessary functions it's still huge compared to the answers here because of the definition for the font.
Anyway, here is the output for HELLO WORLD:
And the code:
## ppmdraw.h
```
#ifndef PPMDRAW_H
#define PPMDRAW_H
#include <fstream>
#include <sstream>
#include <map>
#include <bitset>
#include <vector>
struct pixel{
unsigned char r;
unsigned char g;
unsigned char b;
bool equals(pixel p){
return (r == p.r && g == p.g && b == p.b);
}
};
class PPMDraw
{
public:
PPMDraw(int w, int h);
virtual ~PPMDraw();
void fill(unsigned char r, unsigned char g, unsigned char b);
void set_color(unsigned char r, unsigned char g, unsigned char b);
void draw_point(int x, int y);
void draw_char(int x, int y, char c);
void draw_string(int x, int y, std::string text);
bool save(std::string file);
private:
int width;
int height;
pixel * image;
std::vector<bool> checked;
unsigned char red;
unsigned char green;
unsigned char blue;
void init_alpha();
std::map<char, std::bitset<48> > font;
};
#endif // PPMDRAW_H
```
## ppmdraw.cpp
```
#include "PPMDraw.h"
#include <fstream>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <cmath>
#include <map>
#include <bitset>
#include <vector>
// standard constructor
PPMDraw::PPMDraw(int w, int h){
width = w;
height = h;
// make an array to hold all the pixels, r, g, b for each
image = new pixel[width * height];
// a bitset to use for functions that have to check which pixels have been worked on
checked = std::vector<bool>();
for(int i = 0; i < width * height; i++){
checked.push_back(false);
}
init_alpha();
}
PPMDraw::~PPMDraw(){
if(image != nullptr){
delete[] image;
}
}
void PPMDraw::fill(unsigned char r, unsigned char g, unsigned char b){
for(int i = 0; i < width * height; i++){
image[i + 0] = pixel{r, g, b};
}
}
void PPMDraw::set_color(unsigned char r, unsigned char g, unsigned char b){
red = r;
green = g;
blue = b;
}
void PPMDraw::draw_point(int x, int y){
if(x >= 0 && x < width && y >= 0 && y < height){
image[y * width + x] = pixel{red, green, blue};
}
}
void PPMDraw::draw_char(int x, int y, char c){
std::bitset<48> letter = font[c];
int n = 47;
for(int i = 0; i < 6; i++){
for(int j = 0; j < 8; j++){
if(letter[n]){
draw_point(x + i, y + j);
}
n--;
}
}
}
void PPMDraw::draw_string(int x, int y, std::string text){
for(unsigned int i = 0; i < text.length(); i++){
draw_char(x + 6 * i, y, text[i]);
}
}
bool PPMDraw::save(std::string file){
std::ofstream save(file.c_str(), std::ios_base::out | std::ios_base::binary);
if(save.is_open()){
save << "P6" << std::endl;
save << width << " " << height << std::endl;
save << "255" << std::endl;
unsigned char * temp = new unsigned char[height * width * 3];
for(int i = 0; i < height * width; i++){
temp[i * 3 + 0] = image[i].r;
temp[i * 3 + 1] = image[i].g;
temp[i * 3 + 2] = image[i].b;
}
save.write(reinterpret_cast<const char *> (temp), height*width*3*sizeof(unsigned char));
delete temp;
save.close();
return true;
}else{
return false;
}
}
void PPMDraw::init_alpha(){
// Define a simple font for drawing text
font[' '] = std::bitset<48> (std::string("000000000000000000000000000000000000000000000000"));
font['!'] = std::bitset<48> (std::string("000000000000000011110110000000000000000000000000"));
font['"'] = std::bitset<48> (std::string("000000001100000000000000110000000000000000000000"));
font['#'] = std::bitset<48> (std::string("001010001111111000101000111111100010100000000000"));
font['$'] = std::bitset<48> (std::string("001001000101010011111110010101000100100000000000"));
font['%'] = std::bitset<48> (std::string("000000100100110000010000011000001000010000000000"));
font['&'] = std::bitset<48> (std::string("000111001110001010110010110011000000001000000000"));
font['\\'] = std::bitset<48> (std::string("100000000110000000010000000011000000001000000000"));
font['('] = std::bitset<48> (std::string("000000000000000001111100100000100000000000000000"));
font[')'] = std::bitset<48> (std::string("000000001000001001111100000000000000000000000000"));
font['*'] = std::bitset<48> (std::string("010010000011000011100000001100000100100000000000"));
font['+'] = std::bitset<48> (std::string("000100000001000001111100000100000001000000000000"));
font[','] = std::bitset<48> (std::string("000000000000000000000110000000000000000000000000"));
font['-'] = std::bitset<48> (std::string("000100000001000000010000000100000001000000000000"));
font['.'] = std::bitset<48> (std::string("000000000000000000000100000000000000000000000000"));
font['/'] = std::bitset<48> (std::string("000000100000110000010000011000001000000000000000"));
font['0'] = std::bitset<48> (std::string("011111001000001010000010100000100111110000000000"));
font['1'] = std::bitset<48> (std::string("000000001000001011111110000000100000000000000000"));
font['2'] = std::bitset<48> (std::string("010011101001001010010010100100100111001000000000"));
font['3'] = std::bitset<48> (std::string("010001001000001010000010100100100110110000000000"));
font['4'] = std::bitset<48> (std::string("111100000001000000010000000100001111111000000000"));
font['5'] = std::bitset<48> (std::string("111001001001001010010010100100101001110000000000"));
font['6'] = std::bitset<48> (std::string("011111001001001010010010100100101000110000000000"));
font['7'] = std::bitset<48> (std::string("100000001000000010000110100110001110000000000000"));
font['8'] = std::bitset<48> (std::string("011011001001001010010010100100100110110000000000"));
font['9'] = std::bitset<48> (std::string("011000001001000010010000100100000111111000000000"));
font[':'] = std::bitset<48> (std::string("000000000000000001000100000000000000000000000000"));
font[';'] = std::bitset<48> (std::string("000000000000000001000110000000000000000000000000"));
font['<'] = std::bitset<48> (std::string("000000000001000000101000010001000000000000000000"));
font['='] = std::bitset<48> (std::string("001010000010100000101000001010000000000000000000"));
font['>'] = std::bitset<48> (std::string("000000000100010000101000000100000000000000000000"));
font['?'] = std::bitset<48> (std::string("010000001000000010001010100100000110000000000000"));
font['@'] = std::bitset<48> (std::string("011111001000001010111010101010100111001000000000"));
font['A'] = std::bitset<48> (std::string("011111101001000010010000100100000111111000000000"));
font['B'] = std::bitset<48> (std::string("111111101001001010010010100100100110110000000000"));
font['C'] = std::bitset<48> (std::string("011111001000001010000010100000100100010000000000"));
font['D'] = std::bitset<48> (std::string("111111101000001010000010100000100111110000000000"));
font['E'] = std::bitset<48> (std::string("111111101001001010010010100100101000001000000000"));
font['F'] = std::bitset<48> (std::string("111111101001000010010000100100001000000000000000"));
font['G'] = std::bitset<48> (std::string("011111001000001010000010100010100100110000000000"));
font['H'] = std::bitset<48> (std::string("111111100001000000010000000100001111111000000000"));
font['I'] = std::bitset<48> (std::string("100000101000001011111110100000101000001000000000"));
font['J'] = std::bitset<48> (std::string("000011000000001000000010000000101111110000000000"));
font['K'] = std::bitset<48> (std::string("111111100001000000010000001010001100011000000000"));
font['L'] = std::bitset<48> (std::string("111111100000001000000010000000100000001000000000"));
font['M'] = std::bitset<48> (std::string("111111101000000001100000100000001111111000000000"));
font['N'] = std::bitset<48> (std::string("111111100100000000100000000100001111111000000000"));
font['O'] = std::bitset<48> (std::string("011111001000001010000010100000100111110000000000"));
font['P'] = std::bitset<48> (std::string("111111101001000010010000100100001111000000000000"));
font['Q'] = std::bitset<48> (std::string("011111001000001010001010100001000111101000000000"));
font['R'] = std::bitset<48> (std::string("111111101001000010010000100110001111011000000000"));
font['S'] = std::bitset<48> (std::string("011000101001001010010010100100101000110000000000"));
font['T'] = std::bitset<48> (std::string("100000001000000011111110100000001000000000000000"));
font['U'] = std::bitset<48> (std::string("111111000000001000000010000000101111110000000000"));
font['V'] = std::bitset<48> (std::string("111110000000010000000010000001001111100000000000"));
font['W'] = std::bitset<48> (std::string("111111100000001000001100000000101111111000000000"));
font['X'] = std::bitset<48> (std::string("110001100010100000010000001010001100011000000000"));
font['Y'] = std::bitset<48> (std::string("110000000010000000011110001000001100000000000000"));
font['Z'] = std::bitset<48> (std::string("100001101000101010010010101000101100001000000000"));
font['['] = std::bitset<48> (std::string("000000001111111010000010100000100000000000000000"));
font['\''] = std::bitset<48> (std::string("100000000110000000010000000011000000001000000000"));
font[']'] = std::bitset<48> (std::string("000000001000001010000010111111100000000000000000"));
font['^'] = std::bitset<48> (std::string("001000000100000010000000010000000010000000000000"));
font['_'] = std::bitset<48> (std::string("000000100000001000000010000000100000001000000000"));
font['`'] = std::bitset<48> (std::string("000000001000000001000000000000000000000000000000"));
font['a'] = std::bitset<48> (std::string("000001000010101000101010001010100001111000000000"));
font['b'] = std::bitset<48> (std::string("111111100001001000010010000100100000110000000000"));
font['c'] = std::bitset<48> (std::string("000111000010001000100010001000100001010000000000"));
font['d'] = std::bitset<48> (std::string("000011000001001000010010000100101111111000000000"));
font['e'] = std::bitset<48> (std::string("000111000010101000101010001010100001101000000000"));
font['f'] = std::bitset<48> (std::string("000100000111111010010000100100000000000000000000"));
font['g'] = std::bitset<48> (std::string("001100100100100101001001010010010011111000000000"));
font['h'] = std::bitset<48> (std::string("111111100001000000010000000100000000111000000000"));
font['i'] = std::bitset<48> (std::string("000000000000000001011110000000000000000000000000"));
font['j'] = std::bitset<48> (std::string("000000100000000100000001010111100000000000000000"));
font['k'] = std::bitset<48> (std::string("111111100000100000010100001000100000000000000000"));
font['l'] = std::bitset<48> (std::string("000000000000000011111110000000000000000000000000"));
font['m'] = std::bitset<48> (std::string("000111100001000000001000000100000001111000000000"));
font['n'] = std::bitset<48> (std::string("001111100001000000010000000100000001111000000000"));
font['o'] = std::bitset<48> (std::string("000111000010001000100010001000100001110000000000"));
font['p'] = std::bitset<48> (std::string("001111110010010000100100001001000001100000000000"));
font['q'] = std::bitset<48> (std::string("000110000010010000100100001001000011111100000000"));
font['r'] = std::bitset<48> (std::string("000000000011111000010000000100000000000000000000"));
font['s'] = std::bitset<48> (std::string("000000000001001000101010001010100010010000000000"));
font['t'] = std::bitset<48> (std::string("000000000010000011111110001000000000000000000000"));
font['u'] = std::bitset<48> (std::string("000111000000001000000010000000100001110000000000"));
font['v'] = std::bitset<48> (std::string("000110000000010000000010000001000001100000000000"));
font['w'] = std::bitset<48> (std::string("000111100000001000000100000000100001111000000000"));
font['x'] = std::bitset<48> (std::string("001000100001010000001000000101000010001000000000"));
font['y'] = std::bitset<48> (std::string("001100000000100000000111000010000011000000000000"));
font['z'] = std::bitset<48> (std::string("010001100100101001010010011000100000000000000000"));
font['{'] = std::bitset<48> (std::string("000000000000000001101100100100100000000000000000"));
font['|'] = std::bitset<48> (std::string("000000000000000011111110000000000000000000000000"));
font['}'] = std::bitset<48> (std::string("000000000000000010010010011011000000000000000000"));
font['~'] = std::bitset<48> (std::string("000100000010000000010000000010000001000000000000"));
}
```
## main.cpp
```
#include "PPMDraw.h"
#include <iostream>
int main(){
// ask for input
std::string input;
std::cout << "ENTER YOUR TEXT" << std::endl;
getline(std::cin, input);
// get size for image
int width = input.size() * 6;
PPMDraw image = PPMDraw(width, 8);
image.fill(255, 255, 255);
image.set_color(0, 0, 0);
image.draw_string(0, 0, input);
image.save("text.ppm");
}
```
## Makefile
```
CC = g++
CFLAGS = -Wall -c -std=c++11
LFLAGS = -Wall
OBJS = main.o PPMDraw.o
list: $(OBJS)
$(CC) $(LFLAGS) $(OBJS) -o text2ppm
main.o: PPMDraw.h
$(CC) $(CFLAGS) main.cpp
PPMDraw.o: PPMDraw.h
$(CC) $(CFLAGS) PPMDraw.cpp
clean:
rm *.o main
```
If you're interested, the full PPMDraw library is [here](http://myweb.uiowa.edu/stcrowle/Files/PPMDraw.zip):
[Answer]
# SmileBASIC, 231 bytes
```
LINPUT C$?"P1
?8,LEN(C$)*8WHILE""<C$A=ASC(SHIFT(C$))D=ASC("*N.JZ`;O:²ÞøäüÄho"[A-65+12*(A<34)+47*(A<47)])FOR I=0TO 4B$=BIN$(VAL("7535712074617252"[D>>5<<1OR 1AND D>>I]),8)WHILE""<B$?POP(B$),
WEND?NEXT?"0 "*24WEND
```
[](https://i.stack.imgur.com/9uQCx.png)
Each character contains only 2 different row patterns, chosen from a "palette" of 8 combinations.
The data for each symbol is stored in 1 byte, with the palette stored separately.
] |
[Question]
[
Write a program or function that takes in a non-negative integer N from stdin or as a function argument. It must print or return a string of a hollow ASCII-art square whose sides are each made with N copies of the number N.
### Specifically:
If N is `0`, no copies of N are used, so there should be no output (or only a single trailing newline).
If N is `1`, the output is:
```
1
```
If N is `2`:
```
22
22
```
If N is `3`:
```
333
3 3
333
```
If N is `4`:
```
4444
4 4
4 4
4444
```
If N is `5`:
```
55555
5 5
5 5
5 5
55555
```
The pattern continues for `6` through `9`.
If N is `10`, the output is:
```
10101010101010101010
10 10
10 10
10 10
10 10
10 10
10 10
10 10
10 10
10101010101010101010
```
**Notice that this is not actually square.** It is 10 rows tall but 20 columns wide because `10` is two characters long. This is intended. The point is that each side of the "square" contains N copies of N. **So all inputs beyond `9` will technically be ASCII rectangles.**
For example, if N is `23`, the output is:
```
2323232323232323232323232323232323232323232323
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
23 23
2323232323232323232323232323232323232323232323
```
Here are Pastebins of the required outputs for [`99`](http://pastebin.com/raw/Qcas2Qmu), [`100`](http://pastebin.com/raw/1wc2FNmL), [`111`](http://pastebin.com/raw/DGZcHSiS), and [`123`](http://pastebin.com/raw/ajYdGhmw) (they may look wrong in a browser but in a text editor they'll look correct). The output for `1000` is to large for Pastebin but it would have 1000 rows and 4000 columns. **Numbers with 4 or more digits must work just like smaller numbers.**
### Details:
* N must be written in the usual decimal number representation, with no `+` sign or other non-digits.
* The hollow area must only be filled with spaces.
* No lines should have leading or trailing spaces.
* A single newline after the squares' last line is optionally allowed.
* Languages written after this challenge was made are welcome, they just [aren't eligible to win](http://meta.codegolf.stackexchange.com/a/4870/26997).
* **The shortest code in bytes wins!**
[Answer]
# [Shtriped](http://github.com/HelkaHomba/shtriped), 317 bytes
While I'm making the question, I may as show off my new "purist" language.
```
@ f x
d x
f
@ f x
+ x y
+
i x
@ + y
h x
} x y
e 1
i 1
d y
d 1
d x
} x y
e 0
e 2
i 2
i 2
e 6
+ 2 2 6
+ 2 6 6
e T
+ 2 2 T
+ 6 T T
e N
t N
e P
+ T 0 P
e L
i L
*
e x
*
+ P x x
@ * T
h x
~
} N P 0
d 0
i L
* P
~
~
#
p N
-
s 6
_
@ - L
$
#
@ _ n
#
s 2
@ # N
e n
+ N 0 n
d n
d n
s 2
@ $ n
@ # N
```
(definitely works in [v1.0.0](https://github.com/HelkaHomba/shtriped/releases/tag/v1.0.0))
There are no math operations built into Shtriped except increment and decrement. There's also no looping or conditionals, so all of these thing need to be built up from scratch in every program.
That's what my program does, e.g. `@` is essentially a for loop, `+` is an addition function, `}` is `>=`. The actual output is only produced in the last 8 lines of the program.
There are no strings either in Shtriped. You can take in and print out strings, but they are all represented internally as arbitrary precision integers that can only be incremented and decremented. So there's no easy way get the length of the string `10` for filling in the the square center with the right amount of spaces. I had to cobble together the function `~` that effectively computes `floor(log10(N)) + 1` to find the length of N in decimal.
This could probably be golfed a bit more by rearranging where and how which variables are used, but not *that* much more. There's no getting around Shtriped's inherent limitations. (It was never meant to be a golfing language anyway.)
**Commented code (a backslash is a comment):**
```
@ f x \ function that calls f() x times, returns 0
d x
f
@ f x
+ x y \ returns x + y
+
i x
@ + y
h x
} x y \ returns 1 if x >= y, else 0
e 1
i 1
d y
d 1
d x
} x y
\ declare and set up variables for the numbers 0, 2, 6, 10
e 0 \ 0 is used to help copy values via +
e 2 \ 2 is used for printing newlines
i 2
i 2
e 6 \ 6 is used for printing spaces
+ 2 2 6
+ 2 6 6
e T \ 10 is used for finding the string length of N
+ 2 2 T
+ 6 T T
e N \ declare N
t N \ and set it to what the user inputs
\ all the code from here to the last ~ is for finding the length of N as a string
e P \ P is the current power of 10 (10, 100, 1000...), starting with 10
+ T 0 P
e L \ L will be the length of N in decimal digits
i L
* \ function that returns P times 10 by adding P to itself 10 times
e x
*
+ P x x
@ * T
h x
~ \ function that increments L and multiplies P by 10 until N < P, at which point L will be the string length of N
} N P 0 \ the 0 variable can be used as a dummy now since we don't need it anymore
d 0
i L
* P \ multiply P by 10 to
~
~
\ helper functions for displaying the output
# \ simply prints N as a decimal integer
p N
- \ prints a single space
s 6
_ \ prints L spaces (L = digit length of N)
@ - L
$ \ prints one of the central N-2 lines of the square
#
@ _ n
#
s 2
\ finally, call these functions to display the output
@ # N \ print N copies of N (top line of square)
e n \ declare n and set it to N - 2
+ N 0 n
d n
d n \ if N was 0 or 1 the program will end here, having printed nothing if 0 or just the top line if 1
s 2 \ print a newline
@ $ n \ print the central line of the square N-2 times
@ # N \ print N copies of N (bottom line of square)
\ the output always prints without a trailing newline
```
[Answer]
## Seriously, ~~32~~ ~~31~~ ~~30~~ 29 bytes
```
╩╜ó$╝╜Dbu╜╛*n╜¬;╛l*' *╛+╛@+n(
```
[Try it online!](http://seriously.tryitonline.net/#code=4pWp4pWcw7Mk4pWd4pWcRGJ14pWc4pWbKm7ilZzCrDvilZtsKicgKuKVmyvilZtAK24o&input=MTA)
Explanation:
```
╩╜ó$╝╜Dbu╜╛*n╜¬;╛l*' *╛+╛@+n(
╩ push each input to its own register
(we'll call register 0 "n")
╜ push n to the stack
ó terminate if 0
$╝ push str(n) to register 1
(we'll call register 1 "s")
╜Dbu╜╛*n make min(2,n) copies of s*n (the top and bottom)
(this avoids an extra copy if n is 1)
╜¬; push n-2 twice
╛l*' * push (n-2)*len(s) spaces
╛+╛@+ put s on the front and end of the string (a middle piece)
n push (n-2) total copies of the middle piece
( bring the top piece to the top
```
[Answer]
# C++14, 156 chars
I thought it was a pretty cool solution though obviously can not beat most other entries here.
```
#define f for(i=0;i++<n;c<<t);
[](string t){auto&c=cout;int n=stoi(t),i;f c<<'\n';for(i=0;++i<n-1;c<<t,c.width(~-n*size(t)+1),c.fill(0),c<<t+'\n');if(n-1)f}
```
Ungolfed:
```
#define f for ( i = 0; i++ < n; c << t ); // print top/bot row
[](string t) {
auto& c = cout;
int n = stoi(t), i;
f // print first row
c << '\n'; // kind of annoying but no way to get rid of (yes I tried
// c << '\n'+t instead of c << t+'\n')
for ( i = 0; ++i < n - 1; ) {
c << t; // output the number
// then we we get the width of necessary spaces
c.width(~-n*size(t)+1); // Equivalent to (n-1)*size(t) + 1, but we save
// two bytes since ~- takes precedence over
// multiplication
c.fill(0); // fill with spaces, ' ' == 0
c << t+'\n';
}
if ( n-1 ) f // This if statement is dissapointing
}
```
And like always, to call the function use `[](string t) { ... }("10");`
[Answer]
# Jolf, ~~31~~ ~~27~~ ~~25~~ 23 bytes
```
?=1i1ρρ,aii+*3έέi*li
```
This is encoded in the ISO-8859-7 encoding and contains unprintables, so here's a hexdump:
```
0000000: 3f3d 3169 31f1 f12c 6169 692b 2a33 dd05 ?=1i1..,aii+*3..
0000010: dd69 052a 056c 69 .i.*.li
```
[Try this fiddle online](http://conorobrien-foxx.github.io/Jolf/#code=Pz0xaTHPgc-BLGFpaSsqM86tBc6taQUqBWxp&input=Mw) or [verify all test cases at once (use the full run button)](http://conorobrien-foxx.github.io/Jolf/#code=Pz0xaTHPgc-BLGFpaSsqM86tBc6taQUqBWxp&input=MQoKMgoKMwoKNAoKNQoKMTAKCjIz).
This exits with an error for n = 0, which is [allowed by default.](http://meta.codegolf.stackexchange.com/a/4781/45151)
Massive thanks to Conor for golfing off ~~4~~ 6! bytes. inb4 crossed out four still looks like a four comment
## Explanation
```
?=1i1ρρ,aii+*3έ\x05έi\x05*\x05li
?=1i1 if input is 1 return 1, otherwise...
,aii+*3έ\x05 draw an input x input hollow box of tabs
ρ έi replace all tabs with input
ρ \x05*\x05li replace all spaces with spaces * length of input
```
[Answer]
# JavaScript (ES6), ~~73 82~~ 78 bytes
*Saved a4 bytes thanks to @user81655*
```
n=>(a=n[r='repeat'](n),n<2?a:a+`
${n+' '[r](n.length*(n-2))+n}`[r](n-2)+`
`+a)
```
Takes a string, not a number for input.
[Try it online](http://vihan.org/p/esfiddle/?code=f%3Dn%3D%3E(a%3Dn%5Br%3D'repeat'%5D(n)%2Cn%3C2%3Fa%3Aa%2B%60%0A%24%7Bn%2B'%20'%5Br%5D(n.length*(n-2))%2Bn%7D%60%5Br%5D(n-2)%2B%60%0A%60%2Ba)%0A%0Aalert(%20f(%20'0'%20)%20)%0Aalert(%20f(%20'1'%20)%20)%0Aalert(%20f(%20'2'%20)%20)%0Aalert(%20f(%20'3'%20)%20)%0Aalert(%20f(%20'10'%20)%20)) (all browsers work)
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), ~~34~~ ~~29~~ 26 bytes
```
:G\2<t!+gQ"@!2GVYX1GVnZ"YX
```
This works with [current release (13.0.0)](https://github.com/lmendo/MATL/releases/tag/13.0.0) of the language/compiler
[**Try it online!**](http://matl.tryitonline.net/#code=OkdcMjx0IStnUSJAITJHVllYMUdWbloiWVg&input=MTA)
```
: % array [1,2,...,N], where N is input, taken implicitly
G\ % modulo N. Gives [1,2,...,N-1,0]
2< % smaller than 2? Gives [1,0,...,0,1]
t! % duplicate, transpose
+ % addition with broadcast. Gives 2D array with nonzeros in the border
% and zeros in the interior
gQ % convert to logical, add 1: twos in the border, ones in the interior
" % for each column of that array (note the array is a symmetric matrix,
% so columns and rows are the same)
@! % push column. Transpose into a row
2GVYX % replace twos by the string representation of N, via regexp
1GVnZ"YX % replace ones by as many spaces as length of that string, via regexp
% end for each, implicitly
% display stack contents, implicitly
```
[Answer]
# T-SQL/SQL Server 2012+, 167 161 bytes
```
DECLARE @ INT = 6;
SELECT IIF(u IN(1,s),REPLICATE(s,s),CONCAT(s,REPLICATE(' ',s-2*LEN(s)),s))
FROM(SELECT @ s)z CROSS APPLY(SELECT TOP(s)ROW_NUMBER()OVER(ORDER BY 1/0)u FROM sys.messages)v
```
Output:
```
666666
6 6
6 6
6 6
6 6
666666
```
`**[`LiveDemo`](https://data.stackexchange.com/stackoverflow/query/483695?Size=7&opt.textResults=true)**`
Enter desired size and click `Run query` to get text representation.
Please note that this demo does not display **fixed-width font**. So `7` is thicker than `1`.
---
**EDIT:**
If we treat input as string:
```
DECLARE @ VARCHAR(10) = '7';
SELECT IIF(u IN(1,s),REPLICATE(s,s),s+REPLICATE(' ',s-2*LEN(s))+s)
FROM(SELECT @ s)z CROSS APPLY(SELECT TOP(s+0)ROW_NUMBER()OVER(ORDER BY 1/0)u FROM sys.messages)v
```
`**[`LiveDemo2`](https://data.stackexchange.com/stackoverflow/query/483693?opt.textResults=true)**`
[Answer]
# Julia, 78 bytes
```
n->(s="$n";(p=println)(s^n);[p(s*" "^(n-2)endof(s)*s)for i=2:n-1];n>1&&p(s^n))
```
This is an anonymous function that accepts an integer and prints the ASCII rectangle to STDOUT. To call it, assign it to a variable.
Ungolfed:
```
function f(n)
# Save a string version of n
s = "$n"
# Print the top line
println(s^n)
# Print each middle line
[println(s * " "^(n-2)endof(s) * s) for i = 2:n-1]
# Print the last line if there is one
n > 1 && println(s^n)
end
```
[Try it online](http://goo.gl/9YDL5L)
[Answer]
# Ruby, 100 bytes
```
->n{s="";n.times{|i|s+=(i<1||i>n-2?"#{n}"*n :"#{n}#{' '*[(n-2)*n.to_s.size,0].max}#{n}")+$/};puts s}
```
Too bad I couldn't even manage to beat JS. Any further help golfing it down would be appreciated.
Here's a more or less ungolfed version:
```
def f(n)
n.times{|num|
if num == 0 || num == n-1
s += "#{n}" * n
else
s += "#{n}"+" "*[(n-2)*n.to_s.length,0].max+"#{n}"
end
s += "\n"
}
puts s
end
```
[Answer]
# Retina, 76 bytes
```
.+
$0$*n$0
n(?=n*(\d+))|.
$1_
\d+_
$_¶
T`d` `(?<=¶.*_.*).(?=.*_\d.*¶\d)
\`_
[empty line]
```
Explanation maybe comes tomorrow.
[Try it online here.](http://retina.tryitonline.net/#code=LisKJDAkKm4kMApuKD89biooXGQrKSl8LgokMV8KXGQrXwokX8K2ClRgZGAgYCg_PD3Cti4qXy4qKS4oPz0uKl9cZC4qwrZcZCkKXGBfCg&input=MTI)
[Answer]
## TSQL, ~~112~~ 104 bytes
```
DECLARE @ varchar(10)='12'
PRINT REPLICATE(@,@)+ISNULL('
'+REPLICATE(@+ISNULL(SPACE((@-2)*len(@))+@,'')+'
',@-2)+REPLICATE(@,@),'')
```
>
>
> ```
> 1. generating first line
> 2. adding hollow lines + line breaks
> 3. adding last line(when needed)
>
> ```
>
>
[Answer]
## [Minkolang 0.15](https://github.com/elendiastarman/Minkolang), 57 bytes
```
nd?.d1-2&N.$z01FlOz2-[lz6Z" "I2-z2-*Dz6Z$O]01F.
z[z6Z]$Of
```
[Try it here!](http://play.starmaninnovations.com/minkolang/?code=nd%3F%2Ed1-2%26N%2E%24z01FlOz2-%5Blz6Z%22%20%22I2-z2-*Dz6Z%24O%5D01F%2E%0Az%5Bz6Z%5D%24Of&input=100)
### Explanation
```
n Read number from input
d?. Stop if n=0, continue otherwise
d1-2&N. Print 1 and stop if n=1, continue otherwise
$z Store top of stack in register (z, which is n)
01F Gosub to second line
lO Print newline
z2- Push value from register and subtract 2
[ Pop k and run body of for loop k times
(Does not run if k <= 0)
l Push a newline
z6Z Push z and convert to string
" " Push a space
I2- Push length of stack minus 2
z2- Push z minus 2
* Pop b,a and push a,b
D Pop k and duplicate top of stack k times
z6Z Push z and convert to string
$O Output whole stack as characters
] Close for loop
01F. Gosub to second line and stop after returning.
z[ ] For loop that runs z times
z6Z Push z and convert to string
$O Output whole stack as characters
f Return to position called from
```
[Answer]
# Perl, ~~79~~ ~~76~~ 74 bytes
```
$_=$.=pop;s/./ /g;print$.x$.,$/,($.,$_ x($.-2),$.,$/)x($.-2),$.>1?$.x$.:''
```
Pretty straightforward. The first commandline argument is taken as the number. Place the script in a file and run with `perl file.pl 1`.
[Answer]
## Perl, ~~62~~ ~~60~~ 58 + 2 = 60 bytes
```
for$.(1..$_){say$.>1&$.<$_?$_.$"x(y...c*($_-2)).$_:$_ x$_}
```
Requires `-nlE` flags:
```
$ perl -nlE'for$.(1..$_){say$.>1&$.<$_?$_.$"x(y...c*($_-2)).$_:$_ x$_}' <<< 5
55555
5 5
5 5
5 5
55555
```
With spaces added:
```
for$.(1..$_) {
say(
$. > 1 & $. < $_
? $_ . $"x(length$_*($_-2)) . $_
: $_ x $_
)
}
```
[Answer]
# R, 90 bytes
```
x=scan();m=matrix(x,x,x);k=2:(x-1)*(x>2);m[k,k]=format("",w=nchar(x));write(m,"",n=x,s="")
```
---
This creates a matrix of `x*x` size and then fills with spaces of size `nchar(x)` . If `x` smaller than 2, then nothing is being filled.
[Answer]
# Pyth - 26 bytes
```
K*`QQjbm++Q**l`Q;ttQQttQK
```
[Try it online here](http://pyth.herokuapp.com/?code=%0A%0AK%2a%60QQjbm%2B%2BQ%2a%2al%60Q%3BttQQttQK&input=15&debug=0).
[Answer]
# [Pip](http://github.com/dloscutoff/pip) `-l`, 21 bytes
*Uses language features newer than the question, which is allowed per current policy; if the wording of the question is interpreted to override said policy, see 25-byte answer below.*
```
Yq{MN++g%y>1?sMyy}MCy
```
[Try it online!](https://tio.run/##K8gs@P8/srDa109bO1210s7Qvti3srLW17ny/39Dg/@6OQA)
Thanks to Luis Mendo's [MATL answer](https://codegolf.stackexchange.com/a/73649/16766) for the `(a+1)%n<2` trick.
### Explanation
`Yq` reads a line from stdin and yanks it into `y`. Then:
```
{ }MCy Map this function to each coordinate pair in a y-by-y grid
(Inside the function, the list of both coords is g)
++g Increment both coordinates
%y Take them mod y
MN >1? Test whether the min of the resulting list is 2 or greater
sMy If so, it's in the center; use len(y) spaces
y If not, it's an edge; use the number y
Print result with newlines between rows (implicit, -l flag)
```
---
Original 2016 answer, **25 bytes** (plus `-l` flag):
```
Yq{MN++*a%y<2?ysX#y}MMCGy
```
Changelog:
* `MC` was added more recently; at the time, I used `MMCG` (map-map + coordinate-grid).
* There was a bug in the current interpreter that prevented using `++` on lists, so I had to do `++*` (apply `++` to each element) instead.
* `M`ap has been extended: now `<string1> M <string2>` returns a list of `len(<string2>)` copies of `<string1>`; at the time, I used `sX#y`, string-repeating space by `len(y)`.
[Answer]
## Pyth, ~~37~~ 30 bytes
```
J*K`QQI>Q1JV-Q2++Q*d-lJ*2lKQ;J
```
[Try it here.](https://pyth.herokuapp.com/?code=J%2aK%60QQI%3EQ1JV-Q2%2B%2BQ%2ad-lJ%2a2lKQ%3BJ&input=5&debug=0)
```
J*K`QQ set K to repr(input); that is, stringified
set J to K repeated (input) times
I>Q1 ; if input is greater than 1...
J output J (stringified input times input)
V-Q2 do this (input - 2) times...
++ output the following on one line:
Q the input number
*d-lJ*2lK n spaces, where n = len(J) - 2*len(K)
Q the input number again
; break out of everything
J output J (str(input)*input) one last time,
regardless of whether input > 1
```
[Answer]
# [Retina](https://github.com/mbuettner/retina), 90
Again, I'm pretty sure this will be greatly golfable by the experts:
```
.+
$&$&$*:$&$*;
+`(\d+:):
$1$1
+`([\d+:]+;);
$1$1
T`d` `(?<=;\d+:)[^;]+(?=:\d+:;\d)
:
;
¶
```
[Try it online.](http://retina.tryitonline.net/#code=LisKJCYkJiQqOiQmJCo7CitgKFxkKzopOgokMSQxCitgKFtcZCs6XSs7KTsKJDEkMQpUYGRgIGAoPzw9O1xkKzopW147XSsoPz06XGQrOjtcZCkKOgoKOwrCtg&input=MjM)
[Answer]
# Jelly, 28 bytes
Grr, can’t tell if Jelly is bad at strings, or if I’m bad at Jelly.
```
ŒṘ©L⁶xWẋWẋ$®W¤1¦€U'Z$$4¡j⁷ȯ⁷
```
[Try it online.](http://jelly.tryitonline.net/#code=xZLhuZjCqUzigbZ4V-G6i1fhuoskwq5XwqQxwqbigqxVJ1okJDTCoWrigbfIr-KBtw&input=&args=MTI)
[Answer]
## [Pyke](https://github.com/muddyfish/PYKE/tree/12c0a12837b2ff44733cf0d401da725572dd31d9), 33 bytes (noncompetitive)
```
QD`i*Djli2*lR-k*iRi]3J"bR+2Q-*jR+
```
Explanation:
```
- autoassign Q = eval_or_not(input())
QD`i* - Get the input multiplied by itself
Q - [Q]
D - [Q, Q]
` - [repr(Q), Q]
i - i = stack[0]
* - [stack[0]*stack[1]]
Djli2*lR- - Get number of spaces
D - [^,^]
j - j = stack[0]
l - len(stack[0])
i2* - i*2
l - len(stack[0])
R - rotate_2()
- - stack[0]-stack[1]
k*iRi - Get middle line
k* - " "*^
iRi - [i,^,i]
]3J"bR+ - Join middle line together
]3 - list(stack[:3])
J" - "".join(stack[0])
bR+ - ^+"\n"
2Q- - Get middle lines
2Q-* - Q-2
jR+ - Add end line
jR+ - ^+j
```
[Answer]
## CJam, 27 bytes
```
ri:X,_ff{a+[0X(]&XXs,S*?}N*
```
Thanks to @MartinBüttner for suggesting `ff`. The `a+[0X(]&` is pretty fishy, but oh well.
[Try it online!](http://cjam.aditsu.net/#code=ri%3AX%2C_ff%7Ba%2B%5B0X%28%5D%26XXs%2CS*%3F%7DN*&input=10)
```
ri:X Read input integer and save as variable X
,_ Range, i.e. [0 1 ... X-1] and make a copy
ff{...} Map with extra parameter, twice. This is like doing a Cartesian product
between two 1D arrays, but we get a nice X by X array at the end
For each coordinate pair,
a+ Put the two coordinates into an array
[0X(]& Set intersection with the array [0 X-1]
X Push X
Xs,S* Push a number of spaces equal to the length of X
? Ternary: choose one of the previous two depending on the set intersection
N* Join X by X array with newlines
```
[Answer]
## Haskell, 78 bytes
```
i x=unlines$take x$1#s:3#[s++(3#s>>" ")++s]++[1#s]where s=show x;z#s=[z..x]>>s
```
Usage example:
```
*Main> putStr $ i 4
4444
4 4
4 4
4444
```
The function `>>` comes in handy: `<list> >> <string>` makes `length <list>` copies of `<string>`, e.g. top and bottom lines for `x=10` are `[1..10] >> "10"` -> `"10101010101010101010"`.
[Answer]
## Perl, 72 bytes
```
$_=($.=pop)-2;say for($.x$.,($..($.x$_)=~s/./ /rg.$.)x$_,$.x$.)[0..$.-1]
```
Relies on modern Perl features :
>
> **say** 'something'
>
>
>
is automatically available since Perl 5.10 (simply use v5.10 or later).
>
> str\_expr =~ s/.../.../**r**
>
>
>
happily accepts to work on a rvalue (an str\_expr not necessarily reduced to a scalar variable) to yield a **r**esult (the '**r**' option at the end of the regex) without altering the initial str\_expr.
[Answer]
# PHP, 151 bytes
```
function s($n){for($r=0;$r<$n;$r++){for($c=0;$c<$n;$c++){if($r*$c&&$r!=$n-1&&$c!=$n-1){for($d=0;$d<=log10($n);$d++){echo' ';}}else{echo$n;}}echo"\n";}}
```
Absolute mess, need more time to optimize. `s(Number)` gives you the output.
[Answer]
## Java 8, 280 bytes
```
interface A{static<T>void p(T o){System.out.print(o);}static void main(String[]a){long n=new Long(a[0]),l=a[0].length();for(long i=0;i<n;i++,p(a[0]));p("\n"+(n>1?a[0]:""));for(long j=2;j<n;j++,p(a[0])){for(long i=l*2;i<n*l;i++,p(' '));p(a[0]+"\n");}for(long i=1;i<n;i++)p(a[0]);}}
```
It's only about 10 times as long as the shortest answers, which is really good for Java!
Example run:
```
$ java A 10
10101010101010101010
10 10
10 10
10 10
10 10
10 10
10 10
10 10
10 10
10101010101010101010
```
[Answer]
## Python 3, ~~108~~ ~~96~~ 148 bytes
```
a=input()
b=c=int(a)-2 if a!="1" else 0
print(a*int(a))
while b:print(a+" "*int(len(a))*c+a);b-=1
if a!="1":print(a*int(a))
```
Ungolfed/explained:
```
number = input() # Gets a number as input
iterator = var = int(number) - 2 if number != "1" else 0 # Assigns two variables, one of them an iterator, to the number minus 2 (the amount of middle rows in the square) if the number isn't 1. If it is, it sets the vars to 0 so the while doesn't trigger.
print(number * int(number)) # Prints the top row of the square.
while iterator != 0: # Loops for the middle rows
print(number + " " * int(len(number)) * var + number) # Prints the number, then as many spaces as needed, and the number.
iterator -= 1 # De-increments the iterator.
if number != 1: # Makes sure the number isn't 1, because 1 should return 1.
print(a * int(a)) # Same as the first row, it prints the bottom row.
```
As this is my first [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") answer, some constructive criticism and/or suggestions would be helpful!
[Answer]
# Rust, 141 137 bytes
Abused some formatting stuff, otherwise this would've been a lot longer.
```
|i|{let f=||{for _ in 0..i{print!("{}",i)}println!("")};f();if i>1{for _ in 0..i-2{println!("{}{0:1$}",i,i.to_string().len()*(i-1))}f()}}
```
Unpacked:
```
|i| {
let f = || {
for _ in 0..i {
print!("{}",i)
}
println!("")
};
f();
if i>1 {
for _ in 0..i-2 {
println!("{}{0:1$}",i,i.to_string().len()*(i-1))
}
f()
}
}
```
[Playground Link](https://play.rust-lang.org/?gist=6ffe943a1b9ae16ffbd9cbc295cd3871&version=stable&backtrace=0)
[Answer]
# Powershell, ~~98~~ ~~96~~ ~~95~~ ~~83~~ ~~82~~ 75 bytes
```
param($n)($l="$n"*$n)
if(($m=$n-2)-ge0){,"$n$(' '*"$n".Length*$m)$n"*$m
$l}
```
Ungolfed and explained test script:
```
$f = {
param($n)
($l="$n"*$n) # let $l is a string contains N only and return this value as a first line
$m=$n-2
if($m-ge0){ # if(N>1)
$s=' '*"$n".Length*$m # let $s is spaces inside repeated (length of string represented of n * m)
,"$n$s$n"*$m # return $m strings contains: N, spaces and N
$l # retrun the first line again
}
}
&$f 1
&$f 2
&$f 3
&$f 4
&$f 10
```
Output:
```
1
22
22
333
3 3
333
4444
4 4
4 4
4444
10101010101010101010
10 10
10 10
10 10
10 10
10 10
10 10
10 10
10 10
10101010101010101010
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~28~~ ~~25~~ 19 bytes
```
░*k┴╜o\⌡{khí **k++p
```
[Try it online!](https://tio.run/##y00syUjPz0n7///RtIla2Y@mbHk0dU5@zKOehdXZGYfXKmhpZWtrF/z/b8BlyGXEZcxlwmXKZQjkmHKZGvwHAA "MathGolf – Try It Online")
## Explanation
This was a fun challenge. Disclaimer: this language is younger than the challenge itself, but the methods used for this answer are not designed for this challenge in particular. I realised that I can save a byte for the 1-case, and by reducing the number of print statements.
```
░ convert implicit input to string
* pop a, b : push(a*b)
k read integer from input
┴ check if equal to 1
╜ else without if
o print TOS without popping (handles the 1-case)
\ swap top elements
⌡ decrement twice
{ start block or arbitrary length
k read integer from input
h length of array/string without popping
í get total number of iterations of for loop
space character
* pop a, b : push(a*b)
* pop a, b : push(a*b) (this results in (n-2)*numdigits(n)*" ")
k read integer from input
+ pop a, b : push(a+b)
+ pop a, b : push(a+b)
p print with newline
```
] |
[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/77249/edit).
Closed 7 years ago.
[Improve this question](/posts/77249/edit)
In this challenge you are supposed to fill a grid 10x10 with numbers from 1 to 100 (each number once) following this rules:
* Number 1 must be on the bottom row
* Number 100 must be on the upper row
* Two consecutive numbers must be one next to the other (diagonals doesn't count)
* The grid must be *random*
It's not necessary at all that all possible outcomes are equiprobable. Still, though, there must be a non-zero chance for every possible grid (that satisfies the first 3 conditions) to occur.
I don't want time to be a problem, but to avoid pure brute force, answers should take less than a minute to run.
Since output shouldn't be the main focus of the challenge I give complete freedom on how to write it, as long as each row in the output corresponds to a row in the grid and numbers are separated by a character (of any kind).
]
|
[Question]
[
# Introduction
We've have a few base conversion challenges here in the past, but not many designed to tackle arbitrary length numbers (that is to say, numbers that are long enough that they overflow the integer datatype), and of those, most felt a little complicated. I'm curious how golfed down a change of base code like this can get.
# Challenge
Write a program or function in the language of your choice that can convert a string of one base to a string of another base. Input should be the number to be converted (string), from-base (base-10 number), to-base (base-10 number), and the character set (string). Output should be the converted number (string).
Some further details and rules are as follows:
* The number to be converted will be a non-negative integer (since `-` and `.` may be in the character set). So too will be the output.
* Leading zeroes (the first character in the character set) should be trimmed. If the result is zero, a single zero digit should remain.
* The minimum supported base range is from 2 to 95, consisting of the printable ascii characters.
* The input for the number to be converted, the character set, and the output must all be of the string datatype. The bases must be of the base-10 integer datatype (or integer floats).
* The length of the input number string can be very large. It's hard to quantify a sensible minimum, but expect it to be able to handle at least 1000 characters, and complete 100 characters input in less than 10 seconds on a decent machine (very generous for this sort of problem, but I don't want speed to be the focus).
* You cannot use built in change-of-base functions.
* The character set input can be in any arrangement, not just the typical 0-9a-z...etc.
* Assume that only valid input will be used. Don't worry about error handling.
The winner will be determined by the shortest code that accomplishes the criteria. They will be selected in at least 7 base-10 days, or if/when there have been enough submissions. In the event of a tie, the code that runs faster will be the winner. If close enough in speed/performance, the answer that came earlier wins.
# Examples
Here's a few examples of input and output that your code should be able to handle:
```
F("1010101", 2, 10, "0123456789")
> 85
F("0001010101", 2, 10, "0123456789")
> 85
F("85", 10, 2, "0123456789")
> 1010101
F("1010101", 10, 2, "0123456789")
> 11110110100110110101
F("bababab", 2, 10, "abcdefghij")
> if
F("10", 3, 2, "0123456789")
> 11
F("<('.'<)(v'.'v)(>'.'>)(^'.'^)", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? ")
> !!~~~~~~~!!!~!~~!!!!!!!!!~~!!~!!!!!!~~!~!~!!!~!~!~!!~~!!!~!~~!!~!!~~!~!!~~!!~!~!!!~~~~!!!!!!!!!!!!~!!~!~!~~~~!~~~~!~~~~~!~~!!~~~!~!~!!!~!~~
F("~~~~~~~~~~", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? ")
> ~
F("9876543210123456789", 10, 36, "0123456789abcdefghijklmnopqrstuvwxyz")
> 231ceddo6msr9
F("ALLYOURBASEAREBELONGTOUS", 62, 10, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
> 6173180047113843154028210391227718305282902
F("howmuchwoodcouldawoodchuckchuckifawoodchuckcouldchuckwood", 36, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? ")
> o3K9e(r_lgal0$;?w0[`<$n~</SUk(r#9W@."0&}_2?[n
F("1100111100011010101010101011001111011010101101001111101000000001010010100101111110000010001001111100000001011000000001001101110101", 2, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? ")
> this is much shorter
```
[Answer]
## Seriously, 50 bytes
```
0╗,╝,2┐,3┐,4┐╛`4└í╜2└*+╗`MX╜ε╗W;3└@%4└E╜@+╗3└@\WX╜
```
Hex Dump:
```
30bb2cbc2c32bf2c33bf2c34bfbe6034c0a1bd32c02a2bbb60
4d58bdeebb573b33c0402534c045bd402bbb33c0405c5758bd
```
I'm proud of this one despite its length. Why? Because it worked perfectly on the second try. I wrote it and debugged it in literally 10 minutes. Usually debugging a Seriously program is an hour's labor.
Explanation:
```
0╗ Put a zero in reg0 (build number here)
,╝,2┐,3┐,4┐ Put evaluated inputs in next four regs
╛ Load string from reg1
` `M Map over its chars
4└ Load string of digits
í Get index of char in it.
╜ Load number-so-far from reg0
2└* Multiply by from-base
+ Add current digit.
╗ Save back in reg0
X Discard emptied string/list.
╜ Load completed num from reg0
ε╗ Put empty string in reg0
W W While number is positive
; Duplicate
3└@% Mod by to-base.
4└E Look up corresponding char in digits
╜@+ Prepend to string-so-far.
(Forgetting this @ was my one bug.)
╗ Put it back in reg0
3└@\ integer divide by to-base.
X Discard leftover 0
╜ Load completed string from reg0
Implicit output.
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~115~~ ~~114~~ ~~106~~ ~~105~~ 94 bytes
Golfing suggestions welcome. [Try it online!](https://tio.run/nexus/python2#VU9pU4NADP3Or4hoBcra7larlrre931fQBXdYlfrtgJaXY@/jgjIaDLzkryXvJnErO2DpwvkowgxJClGIdU0w1LA7wXAgQsQlqSy7Jus4nPBdG4oMOjwbhukFVJmy1LkmmFTVmmkQD/gIoIQkltmYzf2dJUQjAn5waTgf/mrkGLOmbTJIuNyILkRTvViudj8c5W6ZcYqghqCRh2BikltfKI@OTXd8G5uk9/vOvz@ofsoev2nIIyeXwavb3JhcWl5ZXVtfWNza3tnd2//4PDo@OT07Pzi8ut6aH54pNQaLevG1ZhJ7Xf303E@mpbmqGimMludA9WIvwE "Python 2 – TIO Nexus")
**Edit:** -9 bytes thanks to mbomb007. -2 bytes thanks to FlipTack.
```
def a(n,f,t,d,z=0,s=''):
for i in n:z=z*f+d.find(i)
while z:s=d[z%t]+s;z/=t
print s or d[0]
```
**Ungolfed:**
```
def arbitrary_base_conversion(num, b_from, b_to, digs, z=0, s=''):
for i in num:
z = z * b_from + digs.index(i)
while z:
s = digs[z % b_to] + s
z = z / t
if s:
return s
else:
return d[0]
```
[Answer]
## CJam, 34 bytes
```
0ll:Af#lif{@*+}~li:X;{XmdA=\}h;]W%
```
Input format is `input_N alphabet input_B output_B` each on a separate line.
[Run all test cases.](http://cjam.aditsu.net/#code=%7B%0A%0A0ll%3AAf%23lif%7B%40*%2B%7D~li%3AX%3B%7BXmdA%3D%5C%7Dh%3B%5DW%25%0A%0A%5DoNo%7D12*&input=1010101%0A0123456789%0A2%0A10%0A0001010101%0A0123456789%0A2%0A10%0A85%0A0123456789%0A10%0A2%0A1010101%0A0123456789%0A10%0A2%0Abababab%0Aabcdefghij%0A2%0A10%0A10%0A0123456789%0A3%0A2%0A%3C('.'%3C)(v'.'v)(%3E'.'%3E)(%5E'.'%5E)%0A~!%40%23%24%25%5E%26*()_%2B-%3D%60%5B%5D%7B%7D%7C'%3B%3A%2C.%2F%3C%3E%3F%20%0A31%0A2%0A~~~~~~~~~~%0A~!%40%23%24%25%5E%26*()_%2B-%3D%60%5B%5D%7B%7D%7C'%3B%3A%2C.%2F%3C%3E%3F%20%0A31%0A2%0A9876543210123456789%0A0123456789abcdefghijklmnopqrstuvwxyz%0A10%0A36%0AALLYOURBASEAREBELONGTOUS%0A0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ%0A62%0A10%0Ahowmuchwoodcouldawoodchuckchuckifawoodchuckcouldchuckwood%0A0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~%60!%40%23%24%25%5E%26*()_-%2B%3D%5B%7B%5D%7D%5C%5C%7C%3B%3A'%5C%22%2C%3C.%3E%2F%3F%20%0A36%0A95%0A1100111100011010101010101011001111011010101101001111101000000001010010100101111110000010001001111100000001011000000001001101110101%0A0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~%60!%40%23%24%25%5E%26*()_-%2B%3D%5B%7B%5D%7D%5C%5C%7C%3B%3A'%5C%22%2C%3C.%3E%2F%3F%20%0A2%0A95)
### Explanation
```
0 e# Push a zero which we'll use as a running total to build up the input number.
l e# Read the input number.
l:A e# Read the alphabet and store it in A.
f# e# For each character in the input number turn it into its position in the alphabet,
e# replacing characters with the corresponding numerical digit value.
li e# Read input and convert to integer.
f{ e# For each digit (leaving the base on the stack)...
@* e# Pull up the running total and multiply it by the base.
+ e# Add the current digit.
}
~ e# The result will be wrapped in an array. Unwrap it.
li:X; e# Read the output base, store it in X and discard it.
{ e# While the running total is not zero yet...
Xmd e# Take the running total divmod X. The modulo gives the next digit, and
e# the division result represents the remaining digits.
A= e# Pick the corresponding character from the alphabet.
\ e# Swap the digit with the remaining value.
}h
; e# We'll end up with a final zero on the stack which we don't want. Discard it.
]W% e# Wrap everything in an array and reverse it, because we've generated the
e# digits from least to most significant.
```
This works for the same byte count:
```
L0ll:Af#lif{@*+}~li:X;{XmdA=@+\}h;
```
The only difference is that we're building up a string instead of collecting everything on the stack and reversing it.
[Answer]
# Ruby, ~~113~~ ~~112~~ ~~105~~ ~~98~~ ~~97~~ ~~95~~ 87 bytes
I sort of double-posted my Python answer (somehow), so here's a Ruby answer. Seven more bytes thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork), another byte thanks to [Martin Büttner](https://codegolf.stackexchange.com/users/8478/martin-b%c3%bcttner), and 8 more bytes thanks to [cia\_rana](https://codegolf.stackexchange.com/users/59228/cia-rana).
```
->n,f,t,d{z=0;s='';n.chars{|i|z=z*f+d.index(i)};(s=d[z%t]+s;z/=t)while z>0;s[0]?s:d[0]}
```
Ungolfed:
```
def a(n,f,t,d)
z=0
s=''
n.chars do |i|
z = z*f + d.index(i)
end
while z>0
s = d[z%t] + s
z /= t
end
if s[0] # if n not zero
return s
else
return d[0]
end
end
```
[Answer]
# C (function) with [GMP library](https://gmplib.org/manual/), 260
This turned out longer than I'd hoped, but here it is anyway. The `mpz_*` stuff really eats up a lot of bytes. I tried `#define M(x) mpz_##x`, but that gave a net gain of 10 bytes.
```
#include <gmp.h>
O(mpz_t N,int t,char*d){mpz_t Q,R;mpz_inits(Q,R,0);mpz_tdiv_qr_ui(Q,R,N,t);mpz_sgn(Q)&&O(Q,t,d);putchar(d[mpz_get_ui(R)]);}F(char*n,int f,int t,char*d){mpz_t N;mpz_init(N);while(*n)mpz_mul_ui(N,N,f),mpz_add_ui(N,N,strchr(d,*n++)-d);O(N,t,d);}
```
The function `F()` is the entry-point. It converts the input string to an `mpz_t` by successive multiplications by the `from`-base and addition of the index of the given digit in the digit list.
The function `O()` is a recursive output function. Each recursion divmods the `mpz_t` by the `to`-base. Because this yields the output digits in reverse order, the recursion effectively allows the digits to be stored on the stack and output in the correct order.
### Test driver:
Newlines and indenting added for readability.
```
#include <stdio.h>
#include <string.h>
#include <gmp.h>
O(mpz_t N,int t,char*d){
mpz_t Q,R;
mpz_inits(Q,R,0);
mpz_tdiv_qr_ui(Q,R,N,t);
mpz_sgn(Q)&&O(Q,t,d);
putchar(d[mpz_get_ui(R)]);
}
F(char*n,int f,int t,char*d){
mpz_t N;
mpz_init(N);
while(*n)
mpz_mul_ui(N,N,f),mpz_add_ui(N,N,strchr(d,*n++)-d);
O(N,t,d);
}
int main (int argc, char **argv) {
int i;
struct test_t {
char *n;
int from_base;
int to_base;
char *digit_list;
} test[] = {
{"1010101", 2, 10, "0123456789"},
{"0001010101", 2, 10, "0123456789"},
{"85", 10, 2, "0123456789"},
{"1010101", 10, 2, "0123456789"},
{"bababab", 2, 10, "abcdefghij"},
{"10", 3, 2, "0123456789"},
{"<('.'<)(v'.'v)(>'.'>)(^'.'^)", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? "},
{"~~~~~~~~~~", 31, 2, "~!@#$%^v&*()_+-=`[]{}|';:,./<>? "},
{"9876543210123456789", 10, 36, "0123456789abcdefghijklmnopqrstuvwxyz"},
{"ALLYOURBASEAREBELONGTOUS", 62, 10, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"},
{"howmuchwoodcouldawoodchuckchuckifawoodchuckcouldchuckwood", 36, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? "},
{"1100111100011010101010101011001111011010101101001111101000000001010010100101111110000010001001111100000001011000000001001101110101", 2, 95, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~`!@#$%^&*()_-+=[{]}\\|;:'\",<.>/? "},
{0}
};
for (i = 0; test[i].n; i++) {
F(test[i].n, test[i].from_base, test[i].to_base, test[i].digit_list);
puts("");
}
return 0;
}
```
[Answer]
## JavaScript (ES6), 140 bytes
```
(s,f,t,m)=>[...s].map(c=>{c=m.indexOf(c);for(i=0;c||i<r.length;i++)r[i]=(n=(r[i]|0)*f+c)%t,c=n/t|0},r=[0])&&r.reverse().map(c=>m[c]).join``
```
Unlike @Mwr247's code (which uses base-f arithmetic to divide s by t each time, collecting each remainder as he goes) I use base-t arithmetic to multiply the answer by f each time, adding each digit of s as I go.
Ungolfed:
```
function base(source, from, to, mapping) {
result = [0];
for (j = 0; j < s.length; s++) {
carry = mapping.indexOf(s[j]);
for (i = 0; carry || i < result.length; i++) {
next = (result[i] || 0) * from + carry;
result[i] = next % to;
carry = Math.floor(next / to);
}
}
string = "";
for (j = result.length; j --> 0; )
string += mapping[result[j]];
return string;
}
```
[Answer]
# APL, 10 bytes
```
{⍺⍺[⍵⍵⍳⍵]}
```
This is an APL operator. In APL, `⍵` and `⍺` are used to pass values, while `⍵⍵` and `⍺⍺` are usually used to pass functions. I'm abusing this here to have 3 arguments. `⍺⍺` is the left argument, `⍵⍵` is the "inner" right argument, and `⍵` is the "outer" right argument.
Basically: `⍺(⍺⍺{...}⍵⍵)⍵`
Then all that's needed is `⍳` to find the positions of the input string in the "from" table, and then use `[]` to index into the "to" table with these positions.
Example:
```
('012345'{⍺⍺[⍵⍵⍳⍵]}'abcdef')'abcabc'
012012
```
[Answer]
# JavaScript (ES6), 175 bytes
```
(s,f,t,h)=>eval('s=[...s].map(a=>h.indexOf(a));n=[];while(s.length){d=m=[],s.map(v=>((e=(c=v+m*f)/t|0,m=c%t),e||d.length?d.push(e):0)),s=d,n.unshift(m)}n.map(a=>h[a]).join``')
```
Figured it's been long enough now that I can submit the one I made to create the examples. I may try and golf it down a bit better later.
[Answer]
# Japt, 9 bytes
```
nVîX
sWîX
```
[Try it](https://ethproductions.github.io/japt/?v=2.0a0&code=blbuWApzV+5Y&input=IjwoJy4nPCkodicuJ3YpKD4nLic+KSheJy4nXikiLCAzMSwgMiwgIn4hQCMkJV52JiooKV8rLT1gW117fXwnOzosLi88Pj8gIg==)
] |
[Question]
[
# It was a warm summer evening...
when my stupid car decided to break down in the middle of the road on my way back from the supermarket. I pushed it to the sideline and decided to walk home. I opened the trunk to take out the grocery and remaining stuff. It was then that I noticed the items were not evenly bagged. Some bags had more heavy items while others had few lighter stuff - some even had a mix of such items. To make it easy for me to carry, I decided to group everything in to two bags and make their weights as close to each other as possible.
# Your goal
is to help me rearrange the items in to two shopping bags in such a way that the difference between both bags is close to zero as possible.
**Mathematically:**
>
> **WEIGHT LEFT HAND — WEIGHT RIGHT HAND ≈ 0**
>
>
>
# Example
If I had only 2 items, Bread and Peanut butter, and the weight of bread is 250 grams and peanut butter is 150 grams, the best way is to carry them separately in two hands.
>
> **WLH - WRH = W(BREAD) - W(P.BUTTER)
>
> 250 - 150 = 100**
>
>
>
The other possibility is :
>
> **W(BREAD, P.BUTTER) - W(empty hand) = (250 + 150) - 0 = 400**
>
>
>
This is not better than our first case, so you should go with the first one.
# Your code should
1. take inputs of numbers indicating weights of items in the shopping bag. Units are not important, but they should be the same (ideally kilograms or grams). Input can be done one by one or all at once. You may restrict the total count to 20 items max, if you want.
2. The input format/type is up to you to choose, but nothing else should be present other than the weights.
3. Any language is allowed, but stick to standard libraries.
4. Display output. Again, you're free to choose the format, but explain the format in your post. ie, how can we tell which ones are left hand items and which ones are right hand items.
# Points
1. Shortest code wins.
# Hint
>
> The two possible algorithms that I could think of are differentiation (faster) and permutations/combinations (slower). You may use these or any other algorithm that does the job.
>
>
>
[Answer]
# Pyth, 9 bytes
```
ehc2osNyQ
```
Input, output formats:
```
Input:
[1, 2, 3, 4, 5]
Output:
[1, 2, 4]
```
[Demonstration.](https://pyth.herokuapp.com/?code=ehc2osNyQ&input=%5B1%2C+2%2C+3%2C+4%2C+5%5D&debug=0)
```
ehc2osNyQ
Q = eval(input())
yQ Take all subsets of Q.
osN Order those element lists by their sums.
c2 Cut the list in half.
eh Take the last element of the first half.
```
This works because `y` returns the subsets in such an order that each subset and its complement are equidistant fom the center. Since the sum of a subset and the sum of its complement will always be equidistant from the center, the list after `osNyQ` will also have this property. Thus, the center two elements of `osNyQ` are complements, and must have an optimal split. We extract the first of those two elements and print it.
[Answer]
# Pyth, 16
```
ho.a-FsMNs./M.pQ
```
This takes the inputs as a pythonic list on STDIN. The output is a list of 2 lists with the first list being the items in one bag, and the second list representing the items in the second bag. This brute forces all combinations, so it will run very slowly (or run out of memory) for large inputs.
[Try it online here](https://pyth.herokuapp.com/?code=ho.a-FsMNs.%2FM.pQ&input=%5B20%2C+10%2C+5%2C+4%2C+6%2C+2%5D&debug=0)
To support the handling of just one input, this goes up to 17:
```
hho.a-FsMNs./M.pQ
```
This will print the values that go in one hand.
[Answer]
# CJam, ~~19~~ 18 bytes
```
{S+m!{S/1fb:*}$W=}
```
This is an anonymous function that pops an array of integers from the stack and returns an array of integers separated by a space.
*Thanks to @jimmy23013 for his ingenious `:*` trick, which saved 1 byte.*
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=%5B1%202%203%204%5D%20%20%20%20%20%20%20%20%20%20e%23%20Input%0A%7BS%2Bm!%7BS%2F1fb%3A*%7D%24W%3D%7D%20e%23%20Function%0A~p%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20e%23%20Call%20and%20print.).
### How it works
```
S+ e# Append a space to the array of integers.
m! e# Push the array of all possible permutations.
{ e# Sort the array by the following:
S/ e# Split the array at the space.
1fb e# Add the integers in each chunk (using base 1 conversion).
:* e# Push the product of both sums.
}$ e# Permutations with a higher product will come last.
W= e# Select the last permutation.
```
Denote the total weight of the shopping bags with **W**. Then, if the bags in one of the hands weigh **W/2 - D/2**, those in the other hand must weigh and **W - (W/2 - D/2) = W/2 + D/2**.
We are trying to minimize the difference **D**. But **(W/2 - D/2)(W/2 + D/2) = W^2/4 - D^2/4**, which becomes larger as **D** becomes smaller.
Thus, the maximal product corresponds to the minimal difference.
[Answer]
# Python 2.7, 161, 160
## code
```
from itertools import*
m=input();h=sum(m)/2.;d=h
for r in(c for o in range(len(m)+1) for c in combinations(m,o)):
t=abs(h-sum(r))
if t<=d:d=t;a=r
print a
```
# Algorithm
>
> **2 x Wone hand = Total weight
>
> Wone hand ~ Total weight / 2**
>
>
>
Check if each combination is getting closer to half of total weight. Iterate and find the best one.
## input
```
>>>[1,2,3,4]
```
## output
```
(2, 3)
```
The displayed tuple goes in one hand, the ones that are not displayed goes in the other (it is not against the rules).
[Answer]
# JavaScript (*ES6*) 117
Using a bit mask to try every possible split, so it is limited to 31 items (ok with the rules). Like the ref answer it outputs just one hand. Note: i look for the minimum difference >=0 to avoid Math.abs, as for each min < 0 there is another > 0, just swapping hands.
To test: run the snippet in Firefox, input a list of numbers comma or space separated.
```
f=(l,n)=>{ // the unused parameter n is inited to 'undefined'
for(i=0;++i<1<<l.length;t<0|t>=n||(r=a,n=t))
l.map(v=>(t+=i&m?(a.push(v),v):-v,m+=m),m=1,t=0,a=[]);
alert(r)
}
// Test
// Redefine alert to avoid that annoying popup when testing
alert=x=>O.innerHTML+=x+'\n';
go=_=>{
var list=I.value.match(/\d+/g).map(x=>+x); // get input and convert to numbers
O.innerHTML += list+' -> ';
f(list);
}
```
```
#I { width: 300px }
```
```
<input id=I value='7 7 7 10 11'><button onclick='go()'>-></button>
<pre id=O></pre>
```
[Answer]
# Haskell, 73 bytes
```
import Data.List
f l=snd$minimum[(abs$sum l-2*sum s,s)|s<-subsequences l]
```
Outputs a list of items in one hand. The missing elements go to the other hand.
Usage: `f [7,7,7,10,11]` -> `[7,7,7]`
For all subsequences `s` of the input list `l` calculate the absolute value of the weight difference between `s` and the missing elements of `l`. Find the minimum.
[Answer]
## Haskell, 51 bytes
```
f l=snd$minimum$((,)=<<abs.sum)<$>mapM(\x->[x,-x])l
```
Output format is that left-hand weights are positive and right-hand weights are negative.
```
>> f [2,1,5,4,7]
[-2,-1,5,4,-7]
```
To generate every possible split, we use `mapM(\x->[x,-x])l` to negate every possible subset of elements. Then, `((,)=<<abs.sum)` labels each one with its absolute sum and `snd$minimum$((,)=<<abs.sum)` take the smallest-labeled element.
I couldn't get it point-free because of type-checking issues.
[Answer]
# Axiom, 292 bytes
```
R==>reduce;F(b,c)==>for i in 1..#b repeat c;p(a)==(#a=0=>[a];w:=a.1;s:=p delete(a,1);v:=copy s;F(s,s.i:=concat([w],s.i));concat(v,s));m(a)==(#a=0=>[[0],a];#a=1=>[a,a];b:=p(a);r:=[a.1];v:=R(+,a)quo 2;m:=abs(v-a.1);F(b,(b.i=[]=>1;d:=abs(v-R(+,b.i));d<m=>(m:=d;r:=copy b.i);m=0=>break));[[m],r])
```
A brute force application. This would minimize the set
```
A={abs(reduce(+,a)quo 2-reduce(+,x))|x in powerSet(a)}
```
because if is minimum
```
y=min(A)=abs(reduce(+,a)quo 2-reduce(+,r))
```
it would be minimum too
```
2*y=abs(reduce(+,a)-2*reduce(+,r))=abs((reduce(+,a)-reduce(+,r))-reduce(+,r))
```
where (reduce(+,a)-reduce(+,r)) and reduce(+,r) are the 2 weight of two bags.(
But that last formula not find to me the minimum, in the application).
Ungolf and results
```
-- Return the PowerSet or the Powerlist of a
powerSet(a)==
#a=0=>[a]
p:=a.1;s:=powerSet delete(a,1);v:=copy s
for i in 1..#s repeat s.i:=concat([p],s.i)
concat(v,s)
-- Return one [[m], r] where
-- r is one set or list with reduce(+,r)=min{abs(reduce(+,a)quo 2-reudece(+,x))|x in powerSet(a)}
-- and m=abs(reduce(+,a) quo 2-reduce(+,r))
-- because each of two part, has to have the same weight
MinDiff(a)==
#a=0=>[[0],a]
#a=1=>[ a ,a]
b:=powerSet(a)
r:=[a.1];v:=reduce(+,a) quo 2;m:=abs(v-a.1)
for i in 1..#b repeat
b.i=[]=>1
k:=reduce(+,b.i)
d:=abs(v-k)
d<m=>(m:=d;r:=copy b.i)
m=0=>break
[[m],r]
--Lista random di n elmenti, casuali compresi tra "a" e "b"
randList(n:PI,a:INT,b:INT):List INT==
r:List INT:=[]
a>b =>r
d:=1+b-a
for i in 1..n repeat
r:=concat(r,a+random(d)$INT)
r
(5) -> a:=randList(12,1,10000)
(5) [8723,1014,2085,5498,2855,1121,9834,326,7416,6025,4852,7905]
Type: List Integer
(6) -> m(a)
(6) [[1],[1014,2085,5498,1121,326,6025,4852,7905]]
Type: List List Integer
(7) -> x:=reduce(+,m(a).2);[x,reduce(+,a)-x]
(7) [28826,28828]
Type: List PositiveInteger
(8) -> m([1,2,3,4])
(8) [[0],[2,3]]
Type: List List Integer
(9) -> m([10,1,2,3,4])
(9) [[0],[10]]
Type: List List Integer
(10) -> m([40,20,80,50,100,33,2])
(10) [[0],[40,20,100,2]]
Type: List List Integer
(11) -> m([7,7,7,10,11])
(11) [[0],[10,11]]
Type: List List Integer
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 7 bytes
```
ṗµ∑;Iht
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLhuZfCteKIkTtJaHQiLCIiLCJbMSwgMiwgMywgNCwgNSwgNl0iXQ==)
Port of [isaacg's Pyth answer](https://codegolf.stackexchange.com/a/51478/100664), go upvote that
```
ṗ # Subsets
µ∑; # Sorted by sum
I # Cut in half
ht # Get the second element of the first half
```
[Answer]
# R (234)
a longer and slower solution with R.
Function:
```
function(p){m=sum(p)/2;n=100;L=length(p);a=matrix(0,n,L+2);for(i in 1:n){idx=sample(1:L,L);a[i,1:L]=idx;j=1;while(sum(p[idx[1:j]])<=m){a[i,L+1]=abs(sum(p[idx[1:j]])-m);a[i,L+2]=j;j=j+1}};b=which.min(a[,L+1]);print(p[a[b,1:a[b,L+2]]])}
```
Expected input - vector with the weights.
Expected output - vector with the weights for one hand.
Example
```
> Weight(c(1,2,3,4))
[1] 3 2
> Weight(c(10,1,2,3,4))
[1] 10
> Weight(c(40,20,80,50,100,33,2))
[1] 100 40 20 2
> Weight(c(7,7,7,10,11))
[1] 7 7 7
```
Human readable code version:
```
weight <- function(input) {
mid <- sum(input)/2
n <- 100
input_Length <- length(input)
answers <- matrix(0, n, input_Length+2)
for(i in 1:n){
idx <- sample(1:input_Length, input_Length)
answers[i, 1:input_Length ] <- idx
j <- 1
while(sum(input[idx[1:j]]) <= mid){
answers[i, input_Length+1] <- abs(sum(input[idx[1:j]]) - mid)
answers[i, input_Length+2] <- j
j <- j + 1
}
}
best_line <- which.min(answers[, input_Length+1])
print(paste("weight diference: ", answers[best_line, input_Length+1]))
print(input[answers[best_line, 1:answers[best_line, input_Length+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/71143/edit).
Closed 8 years ago.
[Improve this question](/posts/71143/edit)
Given four RGB LEDs and 8 colors, your task is to light up each LED in order with a color, and cycle through the LEDs as you cycle through the colors; with only one LED lit up at a time.
So for 8 colors across 4 RGB LEDs, it would look like this (at a hardware level (since there are three channels for each LED)):
```
LED1 LED2 LED3 LED4
0xFF,0x00,0x00 OFF OFF OFF
OFF 0xFF,0XA5,0x00 OFF OFF
OFF OFF 0xFF,0XFF,0x00 OFF
OFF OFF OFF 0x00,0xFF,0x00
0x00,0x0,0xFF OFF OFF OFF
OFF 0xFF,0X00,0xFF OFF OFF
OFF OFF 0xFF,0X00,0xFF OFF
OFF OFF OFF 0xFF,0xC0,0xCB
```
### Inputs:
None
### Program End Condition:
User presses the `SpaceBar` key.
### Program Behavior
There should be a 500ms delay between each LED shift, and each LED will remain "Lit" for 1 second (in our case; this simply means that should the user press the spacebar *before the next color is shown*, then the currently "lit" LED will be chosen. This should happen until the user presses the spacebar.
At that point, output the color the user has chosen.
```
%> myprog
LED COLOR
--- --------
1 0xFF0000
2 0xFFA500
3 0xFFFF00
4 0x00FF00
1 0x0000FF
2 0xFF00FF
```
### Output:
```
1:
2: 0xFF00FF
3:
4:
```
Just because they're beautiful, and to make it a little harder, I chose Magenta and Pink for the final two colors.
### Win Condition
The winning condition is the shortest amount of code in bytes to implement this function.
Any language that is capable of being run from the command line is eligible (although if there's a JavaScript version for the browser that wins; that'd also be interesting).
]
|
[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/15872/edit).
Closed 7 years ago.
[Improve this question](/posts/15872/edit)
You bought a tasty **Orange** in the supermarket and got **78** cents change. How many possible ways the supermarket guy can give you the change using 1,5,10 or 25 coins
* **Input**: Change amount
* **Output**: The number of possible ways to give the change.
Order is not important 1,5 is same as 5,1
Win conditions:
1. **Best performance**
2. **Shortest code**
*Also please add the result for 78 in your title.*
[Answer]
# Mathematica answer= 121, chars=~~74~~ 37
[121 ways to give change of $0.78, in pennies, nickels, dimes, and quarters.]
**Method 1**: FroebeniusSolve
This gives all the ways to solve the Frobenius equation `p + 5n + 10d + 25q = c`:
```
FrobeniusSolve[{1, 5, 10, 25}, #]&
```
The number of ways is (37 chars):
```
Length@FrobeniusSolve[{1,5,10,25},#]&
```
**Examples**
Solutions are of the form, `{pennies, nickels, dimes, quarters}`:
```
FrobeniusSolve[{1, 5, 10, 25}, #]&[21]
```
>
> {{1,0,2,0}, {1,2,1,0}, {1,4,0,0}, {6,1,1,0}, {6,3,0,0}, {11,0,1,0}, {11,2,0,0}, {16,1,0, 0}, {21,0,0,0}}
>
>
>
---
```
Length@FrobeniusSolve[{1,5,10,25},#]&[78]
```
>
> 121
>
>
>
---
**How many ways are there to give change to (.01 to $2.50)?**
```
Length@FrobeniusSolve[{1,5,10,25},#]&/@Range[250] // AbsoluteTiming
```
Timing: 2.004 sec
>
> {2.00398, {{1,
> 1}, {2, 1}, {3, 1}, {4, 1}, {5, 2}, {6, 2}, {7, 2}, {8, 2}, {9,
> 2}, {10, 4}, {11, 4}, {12, 4}, {13, 4}, {14, 4}, {15, 6}, {16,
> 6}, {17, 6}, {18, 6}, {19, 6}, {20, 9}, {21, 9}, {22, 9}, {23,
> 9}, {24, 9}, {25, 13}, {26, 13}, {27, 13}, {28, 13}, {29, 13}, {30,
> 18}, {31, 18}, {32, 18}, {33, 18}, {34, 18}, {35, 24}, {36,
> 24}, {37, 24}, {38, 24}, {39, 24}, {40, 31}, {41, 31}, {42,
> 31}, {43, 31}, {44, 31}, {45, 39}, {46, 39}, {47, 39}, {48,
> 39}, {49, 39}, {50, 49}, {51, 49}, {52, 49}, {53, 49}, {54,
> 49}, {55, 60}, {56, 60}, {57, 60}, {58, 60}, {59, 60}, {60,
> 73}, {61, 73}, {62, 73}, {63, 73}, {64, 73}, {65, 87}, {66,
> 87}, {67, 87}, {68, 87}, {69, 87}, {70, 103}, {71, 103}, {72,
> 103}, {73, 103}, {74, 103}, {75, 121}, {76, 121}, {77, 121}, {78,
> 121}, {79, 121}, {80, 141}, {81, 141}, {82, 141}, {83, 141}, {84,
> 141}, {85, 163}, {86, 163}, {87, 163}, {88, 163}, {89, 163}, {90,
> 187}, {91, 187}, {92, 187}, {93, 187}, {94, 187}, {95, 213}, {96,
> 213}, {97, 213}, {98, 213}, {99, 213}, {100, 242}, {101,
> 242}, {102, 242}, {103, 242}, {104, 242}, {105, 273}, {106,
> 273}, {107, 273}, {108, 273}, {109, 273}, {110, 307}, {111,
> 307}, {112, 307}, {113, 307}, {114, 307}, {115, 343}, {116,
> 343}, {117, 343}, {118, 343}, {119, 343}, {120, 382}, {121,
> 382}, {122, 382}, {123, 382}, {124, 382}, {125, 424}, {126,
> 424}, {127, 424}, {128, 424}, {129, 424}, {130, 469}, {131,
> 469}, {132, 469}, {133, 469}, {134, 469}, {135, 517}, {136,
> 517}, {137, 517}, {138, 517}, {139, 517}, {140, 568}, {141,
> 568}, {142, 568}, {143, 568}, {144, 568}, {145, 622}, {146,
> 622}, {147, 622}, {148, 622}, {149, 622}, {150, 680}, {151,
> 680}, {152, 680}, {153, 680}, {154, 680}, {155, 741}, {156,
> 741}, {157, 741}, {158, 741}, {159, 741}, {160, 806}, {161,
> 806}, {162, 806}, {163, 806}, {164, 806}, {165, 874}, {166,
> 874}, {167, 874}, {168, 874}, {169, 874}, {170, 946}, {171,
> 946}, {172, 946}, {173, 946}, {174, 946}, {175, 1022}, {176,
> 1022}, {177, 1022}, {178, 1022}, {179, 1022}, {180, 1102}, {181,
> 1102}, {182, 1102}, {183, 1102}, {184, 1102}, {185, 1186}, {186,
> 1186}, {187, 1186}, {188, 1186}, {189, 1186}, {190, 1274}, {191,
> 1274}, {192, 1274}, {193, 1274}, {194, 1274}, {195, 1366}, {196,
> 1366}, {197, 1366}, {198, 1366}, {199, 1366}, {200, 1463}, {201,
> 1463}, {202, 1463}, {203, 1463}, {204, 1463}, {205, 1564}, {206,
> 1564}, {207, 1564}, {208, 1564}, {209, 1564}, {210, 1670}, {211,
> 1670}, {212, 1670}, {213, 1670}, {214, 1670}, {215, 1780}, {216,
> 1780}, {217, 1780}, {218, 1780}, {219, 1780}, {220, 1895}, {221,
> 1895}, {222, 1895}, {223, 1895}, {224, 1895}, {225, 2015}, {226,
> 2015}, {227, 2015}, {228, 2015}, {229, 2015}, {230, 2140}, {231,
> 2140}, {232, 2140}, {233, 2140}, {234, 2140}, {235, 2270}, {236,
> 2270}, {237, 2270}, {238, 2270}, {239, 2270}, {240, 2405}, {241,
> 2405}, {242, 2405}, {243, 2405}, {244, 2405}, {245, 2545}, {246,
> 2545}, {247, 2545}, {248, 2545}, {249, 2545}, {250, 2691}}}
>
>
>
---
**Method 2**: Solution by `Solve` (66 chars).
This solves the same equation listed in Method 1, albeit by a more standard method, `Solve`:
```
f[c_]:=Solve[p +5n+10d+25q==c &&p>=0&&n>= 0&&d>=0&&q>= 0,{p,n,d,q},Integers]
```
The number of ways is (74 chars):
```
g@c_:= Length@Solve[p +5n+10d+25q==c &&p>=0&&n>= 0&&d>=0&&q>= 0,{p,n,d,q},Integers]
```
**Examples**
```
f[21]
```
>
> {{p → 1, n → 0, d → 2, q → 0}, {p → 1, n → 2, d → 1, q → 0},
> {p → 1, n → 4, d → 0, q → 0}, {p → 6, n → 1, d → 1, q → 0}, {p → 6, n → 3, d → 0, q → 0},
> {p → 11, n → 0, d → 1, q → 0}, {p → 11, n → 2, d → 0, q → 0}, {p → 16, n → 1,
> d → 0, q → 0}, {p → 21, n → 0, d → 0, q → 0}}
>
>
>
---
```
Length[f[78]]
```
>
> 121
>
>
>
---
**How many ways are there to give change to (.01 to $2.50)?**
```
{#, g[#]} & /@ Range[250] // AbsoluteTiming
```
Timing: 4.72 sec
[Answer]
# K3 (kona), 121.
Simple dynamic progamming. 57 chars.
```
cg:{*{+/x{(y _ x),y#0}/:y*!1+(#x)%y}/[(x#0),1;1 5 10 25]}
cg 78
121
```
Calculate all results up to 250 cents
```
{{+/x{(y _ x),y#0}/:y*!1+(#x)%y}/[(x#0),1;1 5 10 25]} 250
2691 2545 2545 2545 2545 2545 2405 2405 2405 2405 2405 2270 2270 2270 2270 2270 2140 2140 2140 2140 2140 2015 2015 2015 2015 2015 1895 1895 1895 1895 1895 1780 1780 1780 1780 1780 1670 1670 1670 1670 1670 1564 1564 1564 1564 1564 1463 1463 1463 1463 1463 1366 1366 1366 1366 1366 1274 1274 1274 1274 1274 1186 1186 1186 1186 1186 1102 1102 1102 1102 1102 1022 1022 1022 1022 1022 946 946 946 946 946 874 874 874 874 874 806 806 806 806 806 741 741 741 741 741 680 680 680 680 680 622 622 622 622 622 568 568 568 568 568 517 517 517 517 517 469 469 469 469 469 424 424 424 424 424 382 382 382 382 382 343 343 343 343 343 307 307 307 307 307 273 273 273 273 273 242 242 242 242 242 213 213 213 213 213 187 187 187 187 187 163 163 163 163 163 141 141 141 141 141 121 121 121 121 121 103 103 103 103 103 87 87 87 87 87 73 73 73 73 73 60 60 60 60 60 49 49 49 49 49 39 39 39 39 39 31 31 31 31 31 24 24 24 24 24 18 18 18 18 18 13 13 13 13 13 9 9 9 9 9 6 6 6 6 6 4 4 4 4 4 2 2 2 2 2 1 1 1 1 1
```
Time to do so (in milliseconds)
```
\t {{+/x{(y _ x),y#0}/:y*!1+(#x)%y}/[(x#0),1;1 5 10 25]} 250
10
```
Time to calculate up to 5000 cents:
\t {{+/x{(y \_ x),y#0}/:y\*!1+(#x)%y}/[(x#0),1;1 5 10 25]} 5000
360
[Answer]
result=121, javascript with memoize (160 chars)
```
c=[25,10,5,1]
d=[[1],[1],[1],[1]]
function f(x,y){
return d[x][y]||(d[x][y]=c.slice(x).reduce(function(i,j,k){
return i+(j>y?0:f(x+k,y-j))
},0))
}
alert(f(0,prompt()))
```
result=121, javascript without memoize (126 chars)
```
c=[25,10,5,1]
function f(x,y){
return y?c.slice(x).reduce(function(i,j,k){
return i+(j>y?0:f(x+k,y-j))
},0):1
}
alert(f(0,prompt()))
```
[Answer]
# J, 50 48 40
### result: 121
```
g=.{[:+//.@(*/)/0=1 5 10 25|"0 _ ]@i.@>:
```
Using generating functions approach.
I'd say performance is not bad and can be easily made much better.
```
g 78
121
g 248
2545
```
Timing:
```
time'g 78'
0.000254s
```
[Answer]
## Haskell - 51 / 69
Answer: 121
```
_%0=1;[]%_=0;(x:y)%m=sum[y%(m-i*x)|i<-[0..m`div`x]]
```
Call notation: `[1,5,10,25]%78`
Or more complete with an extra line:
```
f=([1,5,10,25]%)
```
The call is just: `f 78`
Efficiency test (should be comparable with David Carraher):
```
main=mapM_(print.([1,5,10,25]%))[1..250]
> ghc -O2 frob.hs && time ./frob
- -
./frob 1.81s user 0.02s system 99% cpu 1.843 total
```
] |
[Question]
[
In the spirit of the holidays, and as someone already started the winter theme([Build a snowman!](https://codegolf.stackexchange.com/questions/15648/build-a-snowman)) I propose a new challenge.
Print the number of days, hours, minutes, and seconds until Christmas(midnight(00:00:00) December 25th) on a stand alone window(not a console) in any unambiguous format you see fit, and continually update it as these values change.
Input - nothing, must read system time.
Shortest code wins :) The strings "Days", "Hours", "Minutes", "Seconds", and "Until Christmas" are free code. You can also flavour them up if you like. Flavouring them up is sheerly for the purpose of producing a nice output. You can not flavour strings for the purpose of making a magic number to save code.
[Answer]
# Ruby with [Shoes](http://shoesrb.com/), 96 - 33 = 63
```
Shoes.app{p=para
animate{p.text="0 days 0 hours 0 minutes #{1387951200-Time.new.to_f} seconds"}}
```
Well, you never said we *couldn't*. ;)
Updates once every frame.
The magic number `1387951200` is Christmas - Dec 25, 2013 00:00.
Sample IRB session for where I got the numbers:
```
irb(main):211:0> "0 days 0 hours 0 minutes seconds".size
=> 33
irb(main):212:0> Time.new(2013,12,25,00,00,00).to_i
=> 1387951200
irb(main):213:0>
```
[Answer]
# PowerShell: 279
*Character count does not take into account any freebies. @Cruncher - please adjust accordingly.*
## Golfed
```
($t=($a='New-Object Windows.Forms')+".Label"|iex).Text=($i={((New-TimeSpan -en 12/25|Out-String)-split"`n")[2..6]});$t.Height=99;($x=iex $a".Form").Controls.Add($t);$x.Text='Time Until Christmas';($s=iex $a".Timer").add_tick({$t.Text=&$i;$x.Refresh()});$s.Start();$x.ShowDialog()
```
This ain't the prettiest thing, either as code or as a window, but it works.
One nice bit is that this isn't just good for 2013 - it'll work in any year, from 00:00 on January 1 until 00:00 on December 25th.
***Warning: The window may become unresponsive - it will continue to update, but you might not be able to move or close it.***
## Un-golfed with comments
```
(
# $t will be the label that displays our countdown clock on the form.
$t=(
# $a is used as a shortcut to address the Forms class later.
$a='New-Object Windows.Forms'
# Tack ".Label" onto the end with iex to finish making $t.
)+".Label"|iex
# Set the text for our label.
).Text=(
# $i will be a script block shortcut for later.
$i={
(
(
# Get the current "Time until Christmas", and output it as a string.
New-TimeSpan -en 12/25|Out-String
# Break the string into newline-delimeted array.
)-split"`n"
# Only output elements 2..6 - Days, Hours, Minutes, Seconds, Milliseconds.
)[2..6]
}
);
# Make sure the label is tall enough to show all the info.
$t.Height=99;
(
# Use iex and $a as shortcut to make $x a "New-Object Windows.Forms.Form".
$x=iex $a".Form"
# Add the label to the form.
).Controls.Add($t);
# Put 'Time Until Christmas' in the title bar for flavor.
$x.Text='Time Until Christmas';
(
# Use iex and $a as shortcut to make $s a "New-Object Windows.Forms.Timer".
$s=iex $a".Timer"
# Tell the timer what to do when it ticks.
).add_tick(
{
# Use the $i script block to update $t.Text.
$t.Text=&$i;
# Reload the form so the updated text displays.
$x.Refresh()
}
);
# Start the timer.
$s.Start();
# Show the form.
$x.ShowDialog();
# Variable cleanup - omit from golfed code.
rv t,a,x,i,s
```
[Answer]
# Mathematica 167 - 44 = 123
The following continually updates a table showing the days, hours, minutes and seconds (in thousandths) until the beginning of Christmas day.
I am unsure how to count discount for the free strings.
```
Dynamic[Grid[Join[{{"Countdown", "until Christmas"}},
{DateDifference[Date[], {2013, 12, 25, 0, 0, 0}, {"Day", "Hour", "Minute", "Second"}],
Clock[{1, 1}, 1]}[[1]] /. d_String :> d <> "s"]] ]
```
---
**A quick and dirty solution**: 104-19 = 85 chars
```
Dynamic@{DateDifference[Date[], {2013, 12, 25, 0, 0, 0}, {"Day", "Hour", "Minute",
"Second"}], Clock[{1, 1}, 1]}[[1]]
```
>
> {{17, "Day"}, {10, "Hour"}, {59, "Minute"}, {51.4011, "Second"}}
>
>
>
[Answer]
# Python 136
I'm sure someone can do this better - I've never used Tkinter before. In particular I bet the `l.pack()` and `l["text"]` can are avoidable.
## Golfed
```
from Tkinter import*
from datetime import datetime as d
r=Tk()
l=Label(r)
l.pack()
while 1:
l["text"]=d(2013,12,25)-d.now()
r.update()
```
[Answer]
# R
Here is a solution for R using GTK+ via the gWidgets package. This is pretty ugly code since I am not familiar with the gWidgets/GTK+ package at all.
## Code
Here is the code:
```
library(gWidgets)
options(guiToolkit="RGtk2")
# FUNCTION compute the hours minutes and seconds from time in seconds
fnHMS = function(timeInSec) {
hours = timeInSec %/% 3600
minutes = (timeInSec %% 3600) %/% 60
seconds = (timeInSec %% 3600) %% 60
return(list(hours = hours, minutes = minutes, seconds = seconds))
}
# test the function
fnHMS(1478843)
# container for the label and the button widget
christmasCountdownContainer = gwindow('Christmas Countdown!!', visible = TRUE)
christmasCountdownGroup = ggroup(horizontal = FALSE,
container = christmasCountdownContainer)
ccWidget1 = glabel(sprintf('%4.0f hours, %4.0f minutes, %4.0f seconds till Christmas!!',
(liHMS <- fnHMS(as.double(difftime(as.POSIXct(strptime('25-12-2013 00:00:01',
format = '%d-%m-%Y %H:%M:%S')),
Sys.time(), units = 'secs'))))[[1]], liHMS[[2]], liHMS[[3]]),
container = christmasCountdownGroup)
ccWidget2 = gbutton("Update!", handler = function(h, ...) {
# retrieve the old value of the ccWidget1
oldValue = svalue(ccWidget1)
liHMS = fnHMS(as.double(difftime(as.POSIXct(strptime('25-12-2013 00:00:01',
format = '%d-%m-%Y %H:%M:%S')),
Sys.time(), units = 'secs')))
svalue(ccWidget1) = sprintf('%4.0f hours, %4.0f minutes, %4.0f seconds till Christmas!!',
liHMS[[1]], liHMS[[2]], liHMS[[3]])
}, container = christmasCountdownGroup)
```
## Output
Here is what the output looks like:
[Answer]
## Dyalog APL, 61
```
{⎕SM[1;]←1 1,⍨⊂⍕(1 4⍴2↓2013 12 24 23 59 59 1000-⎕TS)⍪'Days' 'Hours' 'Minutes' 'Seconds'⋄∇1}1
```
[Answer]
# C# 128
Golfed
```
using D=System.DateTime;using System.Windows.Forms;class C{static void Main(){MessageBox.Show(""+(new D(2013, 12, 25)-D.Now));}}
```
Ungolfed
```
using D=System.DateTime;
using System.Windows.Forms;
class C
{
static void Main()
{
MessageBox.Show(""+(new D(2013,12,25)-D.Now));
}
}
```
[Answer]
## Python 2, 115
```
from datetime import datetime as d
n=d.now()
print str(24-n.day),str(23-n.hour),str(59-n.minute),str(60-n.second)
```
This counts newlines as 2 characters.
] |
[Question]
[
**This question already has answers here**:
[Line numbering - implement nl](/questions/38320/line-numbering-implement-nl)
(8 answers)
Closed 8 years ago.
You must do a program that reads a file given in first argument and print it's content to STDOUT and number the lines on the file, the numbers should be followed by a space.
For instance, assuming that your program is named cat, we could write
`./cat "myfile.txt"` (or execute it with its interpreter)
With myfile.txt:
```
Hello, world, this
is a file with
multiple characters..0
```
And the program should output to STDOUT :
```
1 Hello, world, this
2 is a file with
3 multiple characters..0
```
The shortest program in bytes win.
For example :
Perl
```
$r++&print"$r ".$_ while<>
```
[Answer]
# LabVIEW, 32 [LabVIEW Primitives](http://meta.codegolf.stackexchange.com/a/7589/39490)
Reads line by line and concatenates numbers space and newlines, then deletes a trailing number, space and newline.
[](https://i.stack.imgur.com/QYpgU.gif)
] |
[Question]
[
Write a program or function that takes in a nonempty list of [mathematical inequalities](https://en.wikipedia.org/wiki/Inequality_(mathematics)) that use the less than operator (`<`). Each line in the list will have the form
```
[variable] < [variable]
```
where a `[variable]` may be any nonempty string of lowercase a-z characters. As in normal math and programming, variables with the same name are identical.
If a **positive integer** can be assigned to each variable such that **all** the inequalities are satisfied, then print or return a list of the variables with such an assignment. Each line in this list should have the form
```
[variable] = [positive integer]
```
and all variables must occur exactly once in any order.
Note that there may be many possible positive integer solutions to the set of inequalities. Any one of them is valid output.
If there are no solutions to the inequalities, then either don't output anything or output a [falsy value](http://meta.codegolf.stackexchange.com/a/2194/26997) (it's up to you).
**The shortest code in bytes wins.**
## Examples
If the input were
```
mouse < cat
mouse < dog
```
then all of these would be valid outputs:
```
mouse = 1
cat = 2
dog = 2
```
```
mouse = 37
cat = 194
dog = 204
```
```
mouse = 2
cat = 2000000004
dog = 3
```
If the input were
```
rickon < bran
bran < arya
arya < sansa
sansa < robb
robb < rickon
```
then no assignment is possible because it boils down to `rickon < rickon`, so there either is no output or a falsy output.
**More examples with solutions:**
```
x < y
x = 90
y = 91
---
p < q
p < q
p = 1
q = 2
---
q < p
q < p
p = 2
q = 1
---
abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyzz
abcdefghijklmnopqrstuvwxyz = 123456789
abcdefghijklmnopqrstuvwxyzz = 1234567890
---
pot < spot
pot < spot
pot < spots
pot = 5
spot = 7
spots = 6
---
d < a
d < b
d < c
d < e
d = 1
a = 4
b = 4
c = 5
e = 4
---
aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa
aaaa = 4
aa = 2
aaaaa = 5
a = 1
aaa = 3
---
frog < toad
frog < toaster
toad < llama
llama < hippo
raccoon < science
science < toast
toaster < toad
tuna < salmon
hippo < science
toasted < toast
raccoon = 1
frog = 2
toaster = 3
toasted = 4
toad = 5
llama = 6
hippo = 7
science = 8
toast = 9
tuna = 10
salmon = 11
```
**More examples with no solutions:** (separated by empty lines)
```
z < z
ps < ps
ps < ps
q < p
p < q
p < q
q < p
a < b
b < c
c < a
d < a
d < b
d < c
d < d
abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyz
bolero < minuet
minuet < bolero
aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
aaaaa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa
g < c
a < g
b < a
c < a
g < b
a < g
b < a
c < a
g < b
a < g
b < a
c < b
g < c
a < g
b < a
c < b
geobits < geoborts
geobrits < geoborts
geology < geobits
geoborts < geology
```
[Answer]
# Pyth, 39 bytes
```
V>1f.A<MxMLTN.pS{s=Nm%2cd).zVNjd[H\==hZ
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?input=mouse%20%3C%20cat%0Amouse%20%3C%20dog&code=V%3E1f.A%3CMxMLTN.pS%7Bs%3DNm%252cd%29.zVNjd%5BH%5C%3D%3DhZ)
Brute-forces through all possible permutations (and interpret them as sortings), check if they match the inequalities, and assign them the values `1, 2, ...., n`.
### Explanation
```
f.A<MxMLTN.pS{s=Nm%2cd).z
m .z map each input line d to:
cd) split d by spaces
%2 and remove the second element
=N save this list of pairs to N
s combine these pairs to a big list of variable names
{ set (remove duplicates)
.pS generate all permutations
f filter for permutations T, which satisfy:
xMLTN replace each variable in N by their index in T
.A<M check if each pair is ascending
V>1...VNjd[H\==hZ implicit: Z = 0
>1 remove all but the last filtered permutation (if any)
V for each permutation N in ^ (runs zero times or once):
VN for each variable H in N:
[ generate a list containing:
H H
\= "="
=hZ Z incremented by 1 (and update Z)
jd join this list by spaces and print
```
[Answer]
## CJam (53 52 49 bytes)
```
qS-N/'<f/:A:|e!{A{1$1$&=!},!*},:ee{()" = "\N}f%1<
```
[Online demo](http://cjam.aditsu.net/#code=qS-N%2F'%3Cf%2F%3AA%3A%7Ce!%7BA%7B1%241%24%26%3D!%7D%2C!*%7D%2C%3Aee%7B()%22%20%3D%20%22%5CN%7Df%251%3C&input=aa%20%3C%20aaaaa%0Aa%20%3C%20aa%0Aaaa%20%3C%20aaaa%0Aaa%20%3C%20aaaa%0Aa%20%3C%20aaa%0Aaaaa%20%3C%20aaaaa%0Aaaa%20%3C%20aaaaa%0Aa%20%3C%20aaaaa)
This brute-forces all permutations of the distinct tokens, filtering for those assignments of the numbers `0` to `n-1` which obey all of the constraints, and then formats them, incrementing the numbers, and presents the first one. This is certain to find a solution if there is one, because it's essentially a topological sort.
Thanks to [Reto Koradi](https://codegolf.stackexchange.com/users/32852/reto-koradi) for 3 chars and [Martin Büttner](https://codegolf.stackexchange.com/users/8478/martin-b%c3%bcttner) for 1.
[Answer]
# Mathematica, 83 bytes
```
Quiet@Check[Equal@@@FindInstance[Join[#,#>0&/@(v=Sequence@@@#)],v,Integers][[1]],]&
```
Takes input as a list of inequalities. Either outputs a list of assignments or `Null` if it is impossible.
] |
[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/63350/edit).
Closed 8 years ago.
[Improve this question](/posts/63350/edit)
Anyone remember these things?
[](https://i.stack.imgur.com/zNUTS.png)
Your challenge today is to make the shortest program that involves your pet growing into 1 of at least 7 different creatures.
Your creature will grow into different forms depending on a random percentage from an RNG and the name you give it (from STDIN or equivalent for your language) at each stage the two possible creatures it could develop in must differ. To determine how the name affects growth use the ascii codes for each character and math operations (as you please) that converts the name to a percentage. For example:
```
sum(ASCII value for chars in name) % 101 / 100
E.g. "Joe": (74 + 111 + 101) % 101 / 100 = 286 % 100 / 100 = 84 / 100 = 84%
This can then affect the growth like so: Rarity (as %) * Name (as %)
E.g. 40% * 84%* = 33.6% - This means there is a 33.6% chance it will advance into the rarer
of the two possible creatures and a 66.4% it will advance to the other creature.
```
Your pets life has 4 stages `Birth -> Teenager -> Adult -> Death"=` Each stage must be printed to STDOUT.
Your can create random creature names for your pets but they must be at least 5 characters long (bonus points for creativity), you can also choose the rarity yourself.
This is code golf - usual rules apply - shortest program in bytes wins!
Example:
```
+-> Adult1 (75%) - 45% (Most Common)
+-> Teen1 (60%) +
| +-> Adult2 (25%) - 15%
Child (100%) +
| +-> Adult3 (90%) - 36%
+-> Teen2 (40%) +
+-> Adult4 (10%) - 4% (Super rare)
```
Input:
```
Joe
```
Output:
```
Joe was born.
Joe grew into Teen2.
Joe grew into Adult3.
Joe died.
```
]
|
[Question]
[
A positive integer N is *K*-sparse if there are at least *K* 0s between any two consecutive 1s in its binary representation.
So, the number 1010101 is 1-sparse whereas 101101 is not.
Your task is to find the next 1-sparse number for the given input number. For example, if the input is 12 (`0b1100`) output should be 16 (`0b10000`) and if the input is 18 (`0b10010`) output should be 20 (`0b10100`).
Smallest program or function (in bytes) wins! [Standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/standard-loopholes-which-are-no-longer-funny) disallowed.
[Answer]
# Pyth, 9 bytes
* Borrowing the [`x & (x*2) != 0` algorithm](https://codegolf.stackexchange.com/a/48374/11259) from @alephalpha
* Borrowing [Pyth boilerplate](https://codegolf.stackexchange.com/a/48357/11259) from @Jakube
My first attempt at Pyth:
```
f!.&TyThQ
```
[Try it here](https://pyth.herokuapp.com/?code=f!.%26TyThQ&input=18&debug=0)
```
implicit: Q = input()
f hQ find the first integer T >= Q + 1,
that satisfies the condition:
!.&TyT T & (T * 2) is 0
```
[Answer]
# CJam, ~~14~~ 11 bytes
3 bytes saved thanks to DigitalTrauma.
```
l~{)___+&}g
```
[Test it here.](http://cjam.aditsu.net/#code=l~%7B)___%2B%26%7Dg&input=12)
## Explanation
```
l~ "Read and eval input.";
{ }g "Do while...";
)_ "Increment and duplicate (call this x).";
__+ "Get two more copies and add them to get x and 2x on the stack.";
& "Take their bitwise AND. This is non-zero is as long as x's base-2
representation contains '11'.";
```
This leaves the last number on the stack which is printed automatically at the end of the program.
[Answer]
# Python 2, 44 bytes
This is a complete python program that reads in n, and prints the answer. I think it does quite well in the readability sub-competition.
```
n=input()+1
while'11'in bin(n):n+=1
print n
```
The test results:
```
$ echo 12 | python soln.py
16
$ echo 18 | python soln.py
20
```
[Answer]
# Pyth, ~~12~~ 11 bytes
```
f!}`11.BThQ
```
Try it online: [Pyth Compiler/Executor](https://pyth.herokuapp.com/?code=f!%7D%6011.BThQ&input=12&debug=0).
```
implicit: Q = input()
f hQ find the first integer T >= Q + 1,
that satisfies the condition:
!}`11.BT "11" is not in the binary representation of T
```
[Answer]
# Mathematica, ~~41~~ 30 bytes
Saved 11 bytes thanks to Martin Büttner.
```
#+1//.i_/;BitAnd[i,2i]>0:>i+1&
```
[Answer]
# Perl, 31
```
#!perl -p
sprintf("%b",++$_)=~/11/&&redo
```
Or from the command line:
```
perl -pe'sprintf("%b",++$_)=~/11/&&redo' <<<"18"
```
[Answer]
# APL, 18 bytes
```
1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2}
```
This evaluates to a monadic function. [Try it here.](http://tryapl.org/) Usage:
```
1∘+⍣{~∨/2∧/⍺⊤⍨⍺⍴2} 12
16
```
## Explanation
```
1∘+ ⍝ Increment the input ⍺
⍣{ } ⍝ until
~∨/ ⍝ none of
2∧/ ⍝ the adjacent coordinates contain 1 1 in
⍺⊤⍨⍺⍴2 ⍝ the length-⍺ binary representation of ⍺.
```
[Answer]
## J, 20 characters
A monadic verb. Fixed to obey the rules.
```
(+1 1+./@E.#:)^:_@>:
```
### Explanation
First, this is the verb with spaces and then a little bit less golfed:
```
(+ 1 1 +./@E. #:)^:_@>:
[: (] + [: +./ 1 1 E. #:)^:_ >:
```
Read:
```
] The argument
+ plus
[: +./ the or-reduction of
1 1 E. the 1 1 interval membership in
#: the base-2 representation of the argument,
[: ( )^:_ that to the power limit of
>: the incremented argument
```
>
> The argument plus the or-reduction of the `1 1` interval membership in the base-2 representation of the argument, that to the power limit applied to the incremented argument.
>
>
>
I basically compute if `1 1` occurs in the base-2 representation of the input. If it does, I increment the input. This is put under a power-limit, which means that it is applied until the result doesn't change any more.
[Answer]
# Javascript, 25 19
Using the fact that, for a 1-sparse binary number, `x&2*x == 0`:
```
f=x=>x++&2*x?f(x):x
```
[Answer]
# JavaScript (ES6), 39 ~~43~~
No regexp, no strings, recursive:
```
R=(n,x=3)=>x%4>2?R(++n,n):x?R(n,x>>1):n
```
Iterative version:
```
F=n=>{for(x=3;x%4>2?x=++n:x>>=1;);return n}
```
It's very simple, just using right shift to find a sequence of 11. When I find it, skip to next number. The recursive version is directly derived from the iterative one.
**Ungolfed** and more obvious. To golf, the trickiest part is merging the inner and outer loops (having to init x to 3 at start)
```
F = n=>{
do {
++n; // next number
for(x = n; x != 0; x >>= 1) {
// loop to find 11 in any position
if ((x & 3) == 3) { // least 2 bits == 11
break;
}
}
} while (x != 0) // if 11 was found,early exit from inner loop and x != 0
return n
}
```
[Answer]
# Python 2, 37 bytes
```
f=input()+1
while f&2*f:f+=1
print f
```
Used the logic `x & 2*x == 0` for 1-sparse number.
Thanks to @Nick and @CarpetPython.
[Answer]
# JavaScript, ~~75~~ ~~66~~ 62 bytes
Thanks to Martin Büttner for saving 9 bytes and Pietu1998 for 4 bytes!
```
function n(a){for(a++;/11/.test(a.toString(2));a++);return a;}
```
How it works: it runs a `for` loop starting from `a + 1` as long as the current number is not 1-sparse, and if it is, the loop is interrupted and it returns the current number. To check whether a number is 1-sparse, it converts it to binary and checks whether it does not contain `11`.
Un-golfed code:
```
function nextOneSparseNumber(num) {
for (num++; /11/.test(num.toString(2)); num++);
return num;
}
```
[Answer]
# Julia, 40 bytes
```
n->(while contains(bin(n+=1),"11")end;n)
```
This creates an anonymous function that accepts a single integer as input and returns the next highest 1-sparse integer. To call it, give it a name, e.g. `f=n->...`, and do `f(12)`.
Ungolfed + explanation:
```
function f(n)
# While the string representation of n+1 in binary contains "11",
# increment n. Once it doesn't, we've got the answer!
while contains(bin(n += 1), "11")
end
return(n)
end
```
Examples:
```
julia> f(12)
16
julia> f(16)
20
```
Suggestions and/or questions are welcome as always!
[Answer]
# Python, ~~39~~ 33 bytes
Try it here: <http://repl.it/gpu/2>
In lambda form (thanks to xnor for golfing):
```
f=lambda x:1+x&x/2and f(x+1)or-~x
```
Standard function syntax ~~turned out to be shorter than a lambda for once!~~
```
def f(x):x+=1;return x*(x&x*2<1)or f(x)
```
[Answer]
# [><> (Fish)](http://esolangs.org/wiki/Fish), 31 + 3 = 34 bytes
```
1+:>: 4%:3(?v~~
;n~^?-1:,2-%2<
```
Usage:
```
>python fish.py onesparse.fish -v 12
16
```
3 bytes added for the `-v` flag.
[Answer]
# JavaScript (ECMAScript 6), 40
By recursion:
```
g=x=>/11/.test((++x).toString(2))?g(x):x
```
# JavaScript, 56
Same without arrow functions.
```
function f(x){return/11/.test((++x).toString(2))?f(x):x}
```
[Answer]
# Scala, 65 bytes
```
(n:Int)=>{var m=n+1;while(m.toBinaryString.contains("11"))m+=1;m}
```
(if a named function is required, solution will be 69 bytes)
[Answer]
# Java, 33 bytes.
Uses the method in [this answer](https://codegolf.stackexchange.com/a/48421/84303)
```
n->{for(;(n++&2*n)>0;);return n;}
```
[TIO](https://tio.run/##HcyxDoMgFEDRna94UwNtNK0rqaNbJ8emA1UwWHwYeJo0hG@nptOZ7p3Vrqp5/JTBqRjhoSwmZpF0MGrQ0CXncQLD/6CQma3b29kBIik62L0dYTkq3lOwOD1foMIURWIdmHvBqk3GBy45Xi6n5oyivUohg6YtIKDMRbL@G0kvtd@oXo8FOeSmNvzWCCFZzuUH)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes
```
λd⋏[›x
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLOu2Tii49b4oC6eCIsIiIsIjEyIl0=)
## How?
```
λd⋏[›x
λ # Open a lambda for recursion
d # Double
⋏ # Bitwise AND the doubled input with the input
[ # If this is truthy (non-zero):
›x # Increment and recurse
```
[Answer]
## Ruby, 44
```
->(i){loop{i+=1;break if i.to_s(2)!~/11/};i}
```
Pretty basic. A lambda with an infinite loop and a regexp to test the binary representation. I wish that `loop` yielded and index number.
[Answer]
# Matlab (77 74 bytes)
```
m=input('');for N=m+1:2*m
if ~any(regexp(dec2bin(N),'11'))
break
end
end
N
```
Notes:
* It suffices to test numbers `m+1` to `2*m`, where `m` is the input.
* `~any(x)` is `true` if `x` contains all zeros *or* if `x` is empty
[Answer]
**C (32 bytes)**
```
f(int x){return 2*++x&x?f(x):x;}
```
Recursive implementation of the same algorithm as so many other answers.
[Answer]
# Perl, 16 bytes
Combining the `x&2*x` from various answers (I think [Nick's](/a/48421) first) with [nutki's](/a/48364) `redo` yields:
```
perl -pe'++$_&2*$_&&redo'
```
Tested in Strawberry 5.26.
[Answer]
# Japt, 8 bytes
```
_&ZÑ}fUÄ
```
[Run it online.](https://ethproductions.github.io/japt/?v=1.4.6&code=XyZa0X1mVcQ=&input=MTI=)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly)
```
‘&Ḥ¬Ɗ1#
```
A full program accepting a single, non-negative integer which prints a positive integer (as a monadic link it yields a list containing a single positive integer).
**[Try it online!](https://tio.run/##y0rNyan8//9Rwwy1hzuWHFpzrMtQ@f///4ZmAA "Jelly – Try It Online")**
### How?
Starting at `v=n+1`, and incrementing, double `v` to shift every bit up one place and bit-wise AND with `v` and then perform logical NOT to test if `v` is 1-sparse until one such number is found.
```
‘&Ḥ¬Ɗ1# - Main Link: n e.g. 12
‘ - increment 13
1# - 1-find (start with that as v and increment until 1 match is found) using:
Ɗ - last three links as a dyad:
Ḥ - double v
& - (v) bit-wise AND (with that)
¬ - logical NOT (0->1 else 1)
- implicit print (a single item list prints as just the item would)
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 5 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
╦>ù╤x
```
[Run and debug it](https://staxlang.xyz/#p=cb3e97d178&i=12%0A18&a=1&m=2)
It works using this procedure. The input starts on top of the stack.
* Increment and copy twice.
* Halve the top of the stack.
* Bitwise-and top two elements on the stack.
* If the result is truthy (non-zero) repeat the entire program.
] |
[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/60362/edit).
Closed 7 years ago.
[Improve this question](/posts/60362/edit)
The challenge involves [printing the difference between ICMP originate and receive timestamps](https://stackoverflow.com/a/20186781/1122270).
The idea is being able to [determine which asymmetric internet path is responsible for packet delay](https://networkengineering.stackexchange.com/questions/5132/measure-one-way-latency-jitter-packet-loss).
One can use [`hping`](http://ports.su/net/hping) with `--icmp-ts` option to gain the raw data on [`ICMP_TSTAMP`](http://bxr.su/o/sys/netinet/ip_icmp.h#ICMP_TSTAMP). The task is complicated by the fact that `hping` does a fully-buffered output when piped, so, an extra bit of non-portable code is required to [`unbuffer`](http://ports.su/lang/expect) `hping` prior to applying something like `perl`.
Your programme snippet must execute from POSIX shell, `ksh` or `tcsh`, and output `icmp_seq` (int), `rtt` (float), `tsrtt` (int), `Receive` − `Originate` (int), `Originate` + `rtt` − `Transmit` (int), one set per line, unbuffered or line buffered.
Shortest snippet wins. If needed, you can assume that `unbuffer` is available (taking 9 characters), and `hping` doesn't have an extra `2` in its name. (E.g., do the math to compensate if either are missing from your system and require an alias, which you must provide for your shell and system, but without penalising the score.) Also, subtract the domain name, too (extra bonus if you can make it easier to modify, e.g., appearing as the final argument of the snippet).
This is a sample raw data produced by `hping`, should you wish to use it:
```
# hping --icmp-ts www.internet2.edu
HPING www.internet2.edu (re0 207.75.164.248): icmp mode set, 28 headers + 0 data bytes
len=46 ip=207.75.164.248 ttl=50 id=21731 icmp_seq=0 rtt=114.0 ms
ICMP timestamp: Originate=34679222 Receive=34679279 Transmit=34679279
ICMP timestamp RTT tsrtt=114
len=46 ip=207.75.164.248 ttl=50 id=21732 icmp_seq=1 rtt=114.1 ms
ICMP timestamp: Originate=34680225 Receive=34680282 Transmit=34680282
ICMP timestamp RTT tsrtt=115
^C
--- www.internet2.edu hping statistic ---
2 packets tramitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 114.0/114.0/114.1 ms
#
```
This is a screenshot of a sample complete solution which generates the required output in required format:
```
# unbuffer hping --icmp-ts www.internet2.edu \
| perl -ne 'if (/icmp_seq=(\d+) rtt=(\d+\.\d)/) {($s, $p) = ($1, $2);} \
if (/ate=(\d+) Receive=(\d+) Transmit=(\d+)/) {($o, $r, $t) = ($1, $2, $3);} \
if (/tsrtt=(\d+)/) { \
print $s, "\t", $p, "\t", $1, " = ", $r - $o, " + ", $o + $1 - $t, "\n"; }'
0 114.0 114 = 56 + 58
1 113.8 114 = 57 + 57
2 114.1 115 = 57 + 58
3 114.0 114 = 57 + 57
4 114.3 115 = 57 + 58
5 114.1 115 = 57 + 58
6 113.9 114 = 57 + 57
7 114.0 114 = 57 + 57
8 114.0 114 = 57 + 57
9 114.0 114 = 57 + 57
^C
#
```
[(Note that the math values might be negative.)](https://cs.stackexchange.com/questions/18332/how-to-present-ping-data-from-icmp-timestamp)
]
|
[Question]
[
INPUT: Any string consisting exclusively of lowercase letters via function argument, command line argument, STDIN, or similar.
OUTPUT: Print or return a number that will represent the sum of the distances of the letters according to the following metric:
You take the first and second letter and count the distance between them. The distance is defined by the QWERTY keyboard layout, where every adjacent letter in the same row has distance 1 and every adjacent letter in the same column has distance 2. To measure the distance between letters that aren't adjacent, you take the shortest path between the two.
Examples:
```
q->w is 1 distance apart
q->e is 2 distance
q->a is 2 distance
q->s is 3 distance (q->a->s or q->w->s)
q->m is 10 distance
```
Then you take the second and third letter, then the third and fourth, etc., until you reach the end of the input. The output is the sum of all those distances.
Example input and output:
```
INPUT: qwer
OUTPUT: 3
INPUT: qsx
OUTPUT: 5
INPUT: qmq
OUTPUT: 20
INPUT: tttt
OUTPUT: 0
```
Here is an image showing which letters are in the same column:
This is code golf, so the shortest code in bytes wins!
[Answer]
# Python 2, ~~220~~ ... ~~124~~ 119 Bytes
*Huge thanks to Sp3000 for saving a **lot** of bytes.*
```
f='qwertyuiopasdfghjkl zxcvbnm'.find
g=lambda i:sum(abs(f(x)%10-f(y)%10)+2*abs(f(x)/10-f(y)/10)for x,y in zip(i,i[1:]))
```
Usage:
```
g("tttt") -> 0
```
[Check it out here.](http://ideone.com/5i7yCy)
Slightly ungolfed + explanation:
```
f='qwertyuiopasdfghjkl zxcvbnm'.find # Defining keyboard rows and aliasing find
g=lambda i: # Defining a function g which takes variable i
sum( # Sum of
abs(f(x)%10-f(y)%10) # horizontal distance, and
+ 2*abs(f(x)/10-f(y)/10) # vertical distance,
for x,y in zip(i,i[1:])) # for each pair in the zipped list
# Example of zipping for those unaware:
# Let i = asksis, therefore i[1:] = sksis, and zip would make
# the list of pairs [(a,s),(s,k),(k,s),(s,i),(i,s)].
```
[Answer]
# Java, 266 bytes
```
int c(String q){String[]r={"qwertyuiop","asdfghjkl","zxcvbnm"};int v=0,l=q.length();int[][]p=new int[l][2];for(int i=0;i<l;i++){while(p[i][0]<1)p[i][0]=r[p[i][1]++].indexOf(q.charAt(i))+1;v+=i<1?0:Math.abs(p[i][0]-p[i-1][0])+2*Math.abs(p[i][1]-p[i-1][1]);}return v;}
```
Ungolfed version:
```
int c(String q) {
String[] r = {
"qwertyuiop",
"asdfghjkl",
"zxcvbnm"
};
int v = 0, l = q.length(); // v=return value, l = a shorter way to refer to input length
int[][] p = new int[l][2]; // an array containing two values for each
// letter in the input: first its position
// within the row, then its row number (both
// 1 indexed for golfy reasons)
for(int i = 0; i<l; i++) { // loops through each letter of the input
while (p[i][0] < 1) // this loop populates both values of p[i]
p[i][0] = r[p[i][1]++].indexOf(q.charAt(i))+1;
v += (i<1) ? 0 : Math.abs(p[i][0]-p[i-1][0])+2*Math.abs(p[i][1]-p[i-1][1]); // adds onto return value
}
return v;
}
```
[Answer]
# SWI-prolog, 162 bytes
```
a(A):-a(A,0).
a([A,B|C],T):-Z=`qwertyuiopasdfghjkl0zxcvbnm`,nth0(X,Z,A),nth0(Y,Z,B),R is T+(2*abs(Y//10-X//10)+abs(Y mod 10-X mod 10)),(C=[],print(R);a([B|C],R)).
```
Example: `a(`qmq`)` outputs `20` (And `true` after it but there's nothing I can do about that).
**Edit:** had to use 3 more bytes. My original program passed the test cases given but was actually incorrect (absolute values were misplaced/missing)
Note: if you want to use it on say [Ideone](https://ideone.com/), you have to replace all backquotes ``` to double quotes `"`. Backquotes in my case (which is the current standard in SWI-Prolog) represent codes list for strings, and double-quotes character strings, but this is different in older versions of SWI-Prolog.
[Answer]
# CJam, 50 bytes
```
r{i",ÙZ°^ªýx´|"257b27b=A+Ab}%2ew::.-::z2fb:+
```
Note that the code contains unprintable characters.
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=r%7Bi%22%06%C2%99%2C%08%C3%99Z%C2%B0%C2%9C%5E%18%C2%AA%C3%BD%C2%93x%C2%B4%7C%22257b27b%3DA%2BAb%7D%252ew%3A%3A.-%3A%3Az2fb%3A%2B&input=qsx). If the permalink doesn't work, copy the code from this [paste](http://pastebin.com/HSpWaL2T).
### Background
We start assigning positions **0** to **9** to the letters on the top row, **10** to **18** to the letters on the home row and **20** to **26** to the letters on the bottom row.
The positions of all 26 letters, in alphabetical order, are
```
[10 24 22 12 2 13 14 15 7 16 17 18 26 25 8 9 0 3 11 4 6 23 1 21 5 20]
```
This is an array of length 26. Since arrays wrap around in CJam, and the code point of the letter **h** is **104 = 4 × 26**, we rotate the array 7 units to the left, so that each letter's position can be accessed by its code point.
```
[15 7 16 17 18 26 25 8 9 0 3 11 4 6 23 1 21 5 20 10 24 22 12 2 13 14]
```
Now we encode this array by considering its elements digits of a base 27 number and convert the resulting integer to base 257.
```
[6 153 44 8 217 90 176 156 94 24 170 253 147 120 180 124]
```
By replacing each integers by the corresponding Unicode character, we obtain the string from the source code.
### How it works
```
r e# Read a whitespace separated token from STDIN.
{ e# For each character:
i e# Push its code point.
",ÙZ°^ªýx´|" e# Push that string.
257b27b e# Convert from base 257 to base 27.
A+Ab e# Add 10 and convert to base 10.
e# Examples: 7 -> [1 7], 24 -> [3 4]
}% e#
2ew e# Push all overlapping slices of length 2.
::.- e# Subtract the corresponding components of the pairs in each slice.
::z e# Apply absolute value to the results.
2fb e# Convert each to integer (base 2).
e# Example: [2 5] -> 2 × 2 + 5 = 9
:+ e# Add the distances.
```
] |
[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/57956/edit).
Closed 8 years ago.
[Improve this question](/posts/57956/edit)
# The hamburger joint maHburger has hired you to write a program for them.
It is simple: make an ASCII hamburger, using the key. Sounds simple right? Well these customers are ***super*** picky, but one thing is for sure, they do love onions.
Write a program that accepts the customer's orders, and prints a hamburger with as many onions as possible.
## Key
```
O=Onions
P=Pickles
M=Mustard
K=Ketchup
#=Bread
.=Sesame Seed
&=Meat
_=Nothing
```
## Input
Through stdin, or closest alternative, your program will receive the customer's order.
Arguments: (number of patties) (Condiments preference) (number of pickles) (number of sesame seeds)
Condiments preference:
* M: more mustard (above 50% below 80%)
* K: more ketchup (above 50% below 80%)
* NM: nu mustard
* NK: no ketchup
* NMK: no condiments
* E: Ketchup and Mustard (between 40% and 60% each)
## Rules
* Pickles:
+ Size: 7-21
+ There must be a pickle that is at least 14 characters, if one or more pickles were ordered.
* Mustard:
+ Size: 2-7
+ No mustard may be touching Ketchup.
* Ketchup:
+ Size: 2-7
+ No ketchup may be touching Mustard.
* Onions:
+ If a onion is touching two M's, K's or P's It is considered an M, K, or P as well.
+ An onion may not be touching an M and an K at the same time.
+ An onion may not be at the edge of the hamburger.
+ Only up to 2 onions in and 5 character space.
* Sesame seeds are on the top bun only, and may not be touching each other.
* Nothing: only up to 10 per patty.
* Patties: Customers always order at least 2.
Example:
```
2 E 3 16
```
Means 2 patties, Normal condiments, 3 pickles, 16 sesame seeds
and could produce:
```
###.##########
###.#############.####
##########.###################
###.######.######.######.######.####
#######.#############.##################
###########################.################
#################.#################.##########
###############.#############.##################
##################################################
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
_KKKKKK__MMMMMMMOPPPOPOP_O_PPPPPPOPPPPOPPPPPPPPPOP
##################################################
##################################################
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
KKKKKK_OMMMMMOMO_KOKPPOPPPPPO_MMMMMMMO_OKKKK__OO__
##################################################
##################################################
##################################################
```
## Code Golf
This is code golf, so the shortest code wins.
There are bonuses for the amount of onions your code produces, for the following test cases:
```
"2 E 3 16" -5 bytes per onion
"8 M 25 17" -1 byte per 5 onions
"2 NMK 5 13" -8 bytes per onion
"2 NK 100 500" -20 bytes if your program prints "No maHburger for you!" for impossible hamburgers.
```
The bonuses may change.
## Format
```
# Language name, x bytes
How many onions your program produced, and the hamburgers the program created.
code
explanation (if needed)
```
## ASCII
Any whitespace that doesn't affect the ASCII art is fine.
```
##############
######################
##############################
####################################
########################################
############################################
##############################################
################################################
##################################################
```
Is the top bun
```
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
```
Line of Condiments (50 char long)
```
##################################################
##################################################
```
for every patty
Standard Loopholes apply.
This is my first Code Golf Challenge! Yay!
This challenge was inspired by [this](http://archive.gdusa.com/egdusa/2015//0122e/_img/mcdonalds-loves-minimalism.jpg).
]
|
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
This site is for programming contests and challenges. **General programming questions** are off-topic here. You may be able to get help on [Stack Overflow](http://stackoverflow.com/about).
Closed 8 years ago.
[Improve this question](/posts/55594/edit)
Suppose you are given a pointer to the head of a singly linked list. Normally each node in the list has a pointer to the next element, and the last node's pointer is Null. Unfortunately the list might have been corrupted so that some node's pointer leads back to an earlier node in the list.
How can I design an algorithm to detect whether the linked list is corrupted or not keeping in mind that run time is O(n).
]
|
[Question]
[
You must evaluate a string written in [Reverse Polish notation](http://en.wikipedia.org/wiki/Reverse_Polish_notation) and output the result.
The program must accept an input and return the output. For programming languages that do not have functions to receive input/output, you can assume functions like readLine/print.
You are not allowed to use any kind of "eval" in the program.
Numbers and operators are separated by one **or more** spaces.
You must support at least the +, -, \* and / operators.
You need to add support to negative numbers (for example, `-4` is not the same thing as `0 4 -`) and floating point numbers.
**You can assume the input is valid and follows the rules above**
## Test Cases
Input:
```
-4 5 +
```
Output:
```
1
```
---
Input:
```
5 2 /
```
Output:
```
2.5
```
---
Input:
```
5 2.5 /
```
Output:
```
2
```
---
Input:
```
5 1 2 + 4 * 3 - +
```
Output:
```
14
```
---
Input:
```
4 2 5 * + 1 3 2 * + /
```
Output:
```
2
```
[Answer]
## Ruby - 95 77 characters
```
a=[]
gets.split.each{|b|a<<(b=~/\d/?b.to_f: (j,k=a.pop 2;j.send b,k))}
p a[0]
```
Takes input on stdin.
### Testing code
```
[
"-4 5 +",
"5 2 /",
"5 2.5 /",
"5 1 2 + 4 * 3 - +",
"4 2 5 * + 1 3 2 * + /",
"12 8 3 * 6 / - 2 + -20.5 "
].each do |test|
puts "[#{test}] gives #{`echo '#{test}' | ruby golf-polish.rb`}"
end
```
gives
```
[-4 5 +] gives 1.0
[5 2 /] gives 2.5
[5 2.5 /] gives 2.0
[5 1 2 + 4 * 3 - +] gives 14.0
[4 2 5 * + 1 3 2 * + /] gives 2.0
[12 8 3 * 6 / - 2 + -20.5 ] gives 10.0
```
Unlike the C version this returns the last valid result if there are extra numbers appended to the input it seems.
[Answer]
## Python - 124 chars
```
s=[1,1]
for i in raw_input().split():b,a=map(float,s[:2]);s[:2]=[[a+b],[a-b],[a*b],[a/b],[i,b,a]]["+-*/".find(i)]
print s[0]
```
**Python - 133 chars**
```
s=[1,1]
for i in raw_input().split():b,a=map(float,s[:2]);s={'+':[a+b],'-':[a-b],'*':[a*b],'/':[a/b]}.get(i,[i,b,a])+s[2:]
print s[0]
```
[Answer]
## Scheme, 162 chars
(Line breaks added for clarity—all are optional.)
```
(let l((s'()))(let((t(read)))(cond((number? t)(l`(,t,@s)))((assq t
`((+,+)(-,-)(*,*)(/,/)))=>(lambda(a)(l`(,((cadr a)(cadr s)(car s))
,@(cddr s)))))(else(car s)))))
```
Fully-formatted (ungolfed) version:
```
(let loop ((stack '()))
(let ((token (read)))
(cond ((number? token) (loop `(,token ,@stack)))
((assq token `((+ ,+) (- ,-) (* ,*) (/ ,/)))
=> (lambda (ass) (loop `(,((cadr ass) (cadr stack) (car stack))
,@(cddr stack)))))
(else (car stack)))))
```
---
**Selected commentary**
``(,foo ,@bar)` is the same as `(cons foo bar)` (i.e., it (effectively†) returns a new list with `foo` prepended to `bar`), except it's one character shorter if you compress all the spaces out.
Thus, you can read the iteration clauses as `(loop (cons token stack))` and `(loop (cons ((cadr ass) (cadr stack) (car stack)) (cddr stack)))` if that's easier on your eyes.
``((+ ,+) (- ,-) (* ,*) (/ ,/))` creates an association list with the *symbol* `+` paired with the *procedure* `+`, and likewise with the other operators. Thus it's a simple symbol lookup table (bare words are `(read)` in as symbols, which is why no further processing on `token` is necessary). Association lists have O(n) lookup, and thus are only suitable for short lists, as is the case here. :-P
† This is not technically accurate, but, for non-Lisp programmers, it gets a right-enough idea across.
[Answer]
# MATLAB – 158, 147
```
C=strsplit(input('','s'));D=str2double(C);q=[];for i=1:numel(D),if isnan(D(i)),f=str2func(C{i});q=[f(q(2),q(1)) q(3:end)];else q=[D(i) q];end,end,q
```
(input is read from user input, output printed out).
---
Below is the code prettified and commented, it pretty much implements the [postfix algorithm](https://en.wikipedia.org/wiki/Reverse_Polish_notation#Postfix_algorithm) described (with the assumption that expressions are valid):
```
C = strsplit(input('','s')); % prompt user for input and split string by spaces
D = str2double(C); % convert to numbers, non-numeric are set to NaN
q = []; % initialize stack (array)
for i=1:numel(D) % for each value
if isnan(D(i)) % if it is an operator
f = str2func(C{i}); % convert op to a function
q = [f(q(2),q(1)) q(3:end)]; % pop top two values, apply op and push result
else
q = [D(i) q]; % else push value on stack
end
end
q % show result
```
---
## Bonus:
In the code above, we assume operators are always binary (`+`, `-`, `*`, `/`). We can generalize it by using `nargin(f)` to determine the number of arguments the operand/function requires, and pop the right amount of values from the stack accordingly, as in:
```
f = str2func(C{i});
n = nargin(f);
args = num2cell(q(n:-1:1));
q = [f(args{:}) q(n+1:end)];
```
That way we can evaluate expressions like:
```
str = '6 5 1 2 mean_of_three 1 + 4 * +'
```
where `mean_of_three` is a user-defined function with three inputs:
```
function d = mean_of_three(a,b,c)
d = (a+b+c)/3;
end
```
[Answer]
## c -- 424 necessary character
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define O(X) g=o();g=o() X g;u(g);break;
char*p=NULL,*b;size_t a,n=0;float g,s[99];float o(){return s[--n];};
void u(float v){s[n++]=v;};int main(){getdelim(&p,&a,EOF,stdin);for(;;){
b=strsep(&p," \n\t");if(3>p-b){if(*b>='0'&&*b<='9')goto n;switch(*b){case 0:
case EOF:printf("%f\n",o());return 0;case'+':O(+)case'-':O(-)case'*':O(*)
case'/':O(/)}}else n:u(atof(b));}}
```
Assumes that you have a new enough libc to include `getdelim` in stdio.h. The approach is straight ahead, the whole input is read into a buffer, then we tokenize with `strsep` and use length and initial character to determine the class of each. There is no protection against bad input. Feed it "+ - \* / + - ...", and it will happily pop stuff off the memory "below" the stack until it seg faults. All non-operators are interpreted as floats by `atof` which means zero value if they don't look like numbers.
**Readable and commented:**
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *p=NULL,*b;
size_t a,n=0;
float g,s[99];
float o(){ /* pOp */
//printf("\tpoping '%f'\n",s[n-1]);
return s[--n];
};
void u(float v){ /* pUsh */
//printf("\tpushing '%f'\n",v);
s[n++]=v;
};
int main(){
getdelim(&p,&a,EOF,stdin); /* get all the input */
for(;;){
b=strsep(&p," \n\t"); /* now *b though *(p-1) is a token and p
points at the rest of the input */
if(3>p-b){
if (*b>='0'&&*b<='9') goto n;
//printf("Got 1 char token '%c'\n",*b);
switch (*b) {
case 0:
case EOF: printf("%f\n",o()); return 0;
case '+': g=o(); g=o()+g; u(g); break;
case '-': g=o(); g=o()-g; u(g); break;
case '*': g=o(); g=o()*g; u(g); break;
case '/': g=o(); g=o()/g; u(g); break;
/* all other cases viciously ignored */
}
} else { n:
//printf("Got token '%s' (%f)\n",b,atof(b));
u(atof(b));
}
}
}
```
**Validation:**
```
$ gcc -c99 rpn_golf.c
$ wc rpn_golf.c
9 34 433 rpn_golf.c
$ echo -4 5 + | ./a.out
1.000000
$ echo 5 2 / | ./a.out
2.500000
$ echo 5 2.5 / | ./a.out
2.000000
```
Heh! Gotta quote anything with `*` in it...
```
$ echo "5 1 2 + 4 * 3 - +" | ./a.out
14.000000
$ echo "4 2 5 * + 1 3 2 * + /" | ./a.out
2.000000
```
and my own test case
```
$ echo "12 8 3 * 6 / - 2 + -20.5 " | ./a.out
-20.500000
```
[Answer]
## Haskell (155)
```
f#(a:b:c)=b`f`a:c
(s:_)![]=print s
s!("+":v)=(+)#s!v
s!("-":v)=(-)#s!v
s!("*":v)=(*)#s!v
s!("/":v)=(/)#s!v
s!(n:v)=(read n:s)!v
main=getLine>>=([]!).words
```
[Answer]
## Perl (134)
```
@a=split/\s/,<>;/\d/?push@s,$_:($x=pop@s,$y=pop@s,push@s,('+'eq$_?$x+$y:'-'eq$_?$y-$x:'*'eq$_?$x*$y:'/'eq$_?$y/$x:0))for@a;print pop@s
```
Next time, I'm going to use the recursive regexp thing.
Ungolfed:
```
@a = split /\s/, <>;
for (@a) {
/\d/
? (push @s, $_)
: ( $x = pop @s,
$y = pop @s,
push @s , ( '+' eq $_ ? $x + $y
: '-' eq $_ ? $y - $x
: '*' eq $_ ? $x * $y
: '/' eq $_ ? $y / $x
: 0 )
)
}
print(pop @s);
```
I though F# is my only dream programming language...
[Answer]
### Windows PowerShell, 152 ~~181~~ ~~192~~
In readable form, because by now it's only two lines with no chance of breaking them up:
```
$s=@()
switch -r(-split$input){
'\+' {$s[1]+=$s[0]}
'-' {$s[1]-=$s[0]}
'\*' {$s[1]*=$s[0]}
'/' {$s[1]/=$s[0]}
'-?[\d.]+' {$s=0,+$_+$s}
'.' {$s=$s[1..($s.count)]}}
$s
```
**2010-01-30 11:07** (192) – First attempt.
**2010-01-30 11:09** (170) – Turning the function into a scriptblock solves the scope issues. Just makes each invocation two bytes longer.
**2010-01-30 11:19** (188) – Didn't solve the scope issue, the test case just masked it. Removed the index from the final output and removed a superfluous line break, though. And changed double to `float`.
**2010-01-30 11:19** (181) – Can't even remember my own advice. Casting to a numeric type can be done in a single char.
**2010-01-30 11:39** (152) – Greatly reduced by using regex matching in the `switch`. Completely solves the previous scope issues with accessing the stack to pop it.
[Answer]
**[Racket](http://racket-lang.org) 131:**
```
(let l((s 0))(define t(read))(cond[(real? t)
(l`(,t,@s))][(memq t'(+ - * /))(l`(,((eval t)(cadr s)
(car s)),@(cddr s)))][0(car s)]))
```
Line breaks optional.
Based on Chris Jester-Young's solution for Scheme.
[Answer]
## Python, 166 characters
```
import os,operator as o
S=[]
for i in os.read(0,99).split():
try:S=[float(i)]+S
except:S=[{'+':o.add,'-':o.sub,'/':o.div,'*':o.mul}[i](S[1],S[0])]+S[2:]
print S[0]
```
[Answer]
# Python 3, 119 bytes
```
s=[]
for x in input().split():
try:s+=float(x),
except:o='-*+'.find(x);*s,a,b=s;s+=(a+b*~-o,a*b**o)[o%2],
print(s[0])
```
Input: `5 1 1 - -7 0 * + - 2 /`
Output: `2.5`
(You can find a 128-character Python 2 version in the edit history.)
[Answer]
# JavaScript (157)
This code assumes there are these two functions: readLine and print
```
a=readLine().split(/ +/g);s=[];for(i in a){v=a[i];if(isNaN(+v)){f=s.pop();p=s.pop();s.push([p+f,p-f,p*f,p/f]['+-*/'.indexOf(v)])}else{s.push(+v)}}print(s[0])
```
[Answer]
## Perl, 128
This isn't really competitive next to the other Perl answer, but explores a different (suboptimal) path.
```
perl -plE '@_=split" ";$_=$_[$i],/\d||
do{($a,$b)=splice@_,$i-=2,2;$_[$i--]=
"+"eq$_?$a+$b:"-"eq$_?$a-$b:"*"eq$_?
$a*$b:$a/$b;}while++$i<@_'
```
Characters counted as diff to a simple `perl -e ''` invocation.
[Answer]
# flex - 157
```
%{
float b[100],*s=b;
#define O(o) s--;*(s-1)=*(s-1)o*s;
%}
%%
-?[0-9.]+ *s++=strtof(yytext,0);
\+ O(+)
- O(-)
\* O(*)
\/ O(/)
\n printf("%g\n",*--s);
.
%%
```
If you aren't familiar, compile with `flex rpn.l && gcc -lfl lex.yy.c`
[Answer]
Python, 161 characters:
```
from operator import*;s=[];i=raw_input().split(' ')
q="*+-/";o=[mul,add,0,sub,0,div]
for c in i:
if c in q:s=[o[ord(c)-42](*s[1::-1])]+s
else:s=[float(c)]+s
print(s[0])
```
[Answer]
## PHP, ~~439~~ ~~265~~ ~~263~~ ~~262~~ ~~244~~ 240 characters
```
<? $c=fgets(STDIN);$a=array_values(array_filter(explode(" ",$c)));$s[]=0;foreach($a as$b){if(floatval($b)){$s[]=$b;continue;}$d=array_pop($s);$e=array_pop($s);$s[]=$b=="+"?$e+$d:($b=="-"?$e-$d:($b=="*"?$e*$d:($b=="/"?$e/$d:"")));}echo$s[1];
```
This code should work with stdin, though it is not tested with stdin.
It has been tested on all of the cases, the output (and code) for the last one is here:
<http://codepad.viper-7.com/fGbnv6>
**Ungolfed, ~~314~~ ~~330~~ 326 characters**
```
<?php
$c = fgets(STDIN);
$a = array_values(array_filter(explode(" ", $c)));
$s[] = 0;
foreach($a as $b){
if(floatval($b)){
$s[] = $b;
continue;
}
$d = array_pop($s);
$e = array_pop($s);
$s[] = $b == "+" ? $e + $d : ($b == "-" ? $e - $d : ($b == "*" ? $e * $d : ($b == "/" ? $e / $d :"")));
}
echo $s[1];
```
[Answer]
## Python, 130 characters
Would be 124 characters if we dropped `b and` (which some of the Python answers are missing). And it incorporates 42!
```
s=[]
for x in raw_input().split():
try:s=[float(x)]+s
except:b,a=s[:2];s[:2]=[[a*b,a+b,0,a-b,0,b and a/b][ord(x)-42]]
print s[0]
```
[Answer]
# Python 3, ~~126~~ 132 chars
```
s=[2,2]
for c in input().split():
a,b=s[:2]
try:s[:2]=[[a+b,b-a,a*b,a and b/a]["+-*/".index(c)]]
except:s=[float(c)]+s
print(s[0])
```
There have been better solutions already, but now that I had written it (without having read the prior submissions, of course - even though I have to admit that my code looks as if I had copypasted them together), I wanted to share it, too.
[Answer]
# C, 232 229 bytes
Fun with recursion.
```
#include <stdlib.h>
#define b *p>47|*(p+1)>47
char*p;float a(float m){float n=strtof(p,&p);b?n=a(n):0;for(;*++p==32;);m=*p%43?*p%45?*p%42?m/n:m*n:m-n:m+n;return*++p&&b?a(m):m;}main(c,v)char**v;{printf("%f\n",a(strtof(v[1],&p)));}
```
## Ungolfed:
```
#include <stdlib.h>
/* Detect if next char in buffer is a number */
#define b *p > 47 | *(p+1) > 47
char*p; /* the buffer */
float a(float m)
{
float n = strtof(p, &p); /* parse the next number */
/* if the next thing is another number, recursively evaluate */
b ? n = a(n) : 0;
for(;*++p==32;); /* skip spaces */
/* Perform the arithmetic operation */
m = *p%'+' ? *p%'-' ? *p%'*' ? m/n : m*n : m-n : m+n;
/* If there's more stuff, recursively parse that, otherwise return the current computed value */
return *++p && b ? a(m) : m;
}
int main(int c, char **v)
{
printf("%f\n", a(strtof(v[1], &p)));
}
```
## Test Cases:
```
$ ./a.out "-4 5 +"
1.000000
$ ./a.out "5 2 /"
2.500000
$ ./a.out "5 2.5 /"
2.000000
$ ./a.out "5 1 2 + 4 * 3 - +"
14.000000
$ ./a.out "4 2 5 * + 1 3 2 * + /"
2.000000
```
[Answer]
# JavaScript ES7, 119 bytes
I'm getting a bug with array comprehensions so I've used `.map`
```
(s,t=[])=>(s.split` `.map(i=>+i?t.unshift(+i):t.unshift((r=t.pop(),o=t.pop(),[r+o,r-o,r*o,r/o]['+-*/'.indexOf(i)]))),t)
```
[Try it online at ESFiddle](http://server.vihan.ml/p/esfiddle/?code=f%3D(s%2Ct%3D%5B%5D)%3D%3E(s.split%60%20%60.map(i%3D%3E%2Bi%3Ft.unshift(%2Bi)%3At.unshift((r%3Dt.pop()%2Co%3Dt.pop()%2C%5Br%2Bo%2Cr-o%2Cr*o%2Cr%2Fo%5D%5B'%2B-*%2F'.indexOf(i)%5D)))%2Ct)%3B%0A%0Af(%2211%203%20%2B%22))
[Answer]
# C 153
Sometimes a program can be made a bit shorter with more golfing and sometimes you just take completely the wrong route and the much better version is found by someone else.
**Thanks to @ceilingcat for finding a much better (and shorter) version**
```
double atof(),s[99],*p=s;y,z;main(c,v)char**v;{for(;--c;*p=z?z-2?~z?z-4?p+=2,atof(*v):*p/y:*p*y:*p-y:*p+y)z=1[*++v]?9:**v-43,y=*p--;printf("%f\n",s[1]);}
```
[Try it online!](https://tio.run/##HY7RCoIwGIVfJYRg@7chml3oGHsQ88JWK6F0qA1m1Kv/bd1858A5HI4RN2MQL9Pr/Lju@nWyhPKlreuOg1OLDHyTz34YieGemns/A3j5ttNMpBBGxs6mN1Hqb5JKO6ZK/l8BTxtweYiABJHAAt1U0QJjvtN1E7dEdeBBxVhINw/jakm2t6cxix@KjsoPIlZY4hEBGRZ4iD65/Ac "C (gcc) – Try It Online")
My original version:
```
#include <stdlib.h>
#define O(x):--d;s[d]=s[d]x s[d+1];break;
float s[99];main(c,v)char**v;{for(int i=1,d=0;i<c;i++)switch(!v[i][1]?*v[i]:' '){case'+'O(+)case'-'O(-)case'*'O(*)case'/'O(/)default:s[++d]=atof(v[i]);}printf("%f\n",s[1]);}
```
If you are compiling it with mingw32 you need to turn off globbing (see <https://www.cygwin.com/ml/cygwin/1999-11/msg00052.html>) by compiling like this:
```
gcc -std=c99 x.c C:\Applications\mingw32\i686-w64-mingw32\lib\CRT_noglob.o
```
If you don't \* is automatically expanded by the mingw32 CRT into filenames.
[Answer]
## PHP - 259 characters
```
$n=explode(" ",$_POST["i"]);$s=array();for($i=0;$i<count($n);$s=$d-->0?array_merge($s,!$p?array($b,$a,$c):array($p)):$s){if($c=$n[$i++]){$d=1;$a=array_pop($s);$b=array_pop($s);$p=$c=="+"?$b+$a:($c=="-"?$b-$a:($c=="*"?$b*$a:($c=="/"?$b/$a:false)));}}echo$s[2];
```
Assuming input in POST variable *i*.
[Answer]
## C# - 392 characters
```
namespace System.Collections.Generic{class P{static void Main(){var i=Console.ReadLine().Split(' ');var k=new Stack<float>();float o;foreach(var s in i)switch (s){case "+":k.Push(k.Pop()+k.Pop());break;case "-":o=k.Pop();k.Push(k.Pop()-o);break;case "*":k.Push(k.Pop()*k.Pop());break;case "/":o=k.Pop();k.Push(k.Pop()/o);break;default:k.Push(float.Parse(s));break;}Console.Write(k.Pop());}}}
```
However, if arguments can be used instead of standard input, we can bring it down to
## C# - 366 characters
```
namespace System.Collections.Generic{class P{static void Main(string[] i){var k=new Stack<float>();float o;foreach(var s in i)switch (s){case "+":k.Push(k.Pop()+k.Pop());break;case "-":o=k.Pop();k.Push(k.Pop()-o);break;case "*":k.Push(k.Pop()*k.Pop());break;case "/":o=k.Pop();k.Push(k.Pop()/o);break;default:k.Push(float.Parse(s));break;}Console.Write(k.Pop());}}}
```
[Answer]
### Scala 412 376 349 335 312:
```
object P extends App{
def p(t:List[String],u:List[Double]):Double={
def a=u drop 2
t match{
case Nil=>u.head
case x::y=>x match{
case"+"=>p(y,u(1)+u(0)::a)
case"-"=>p(y,u(1)-u(0)::a)
case"*"=>p(y,u(1)*u(0)::a)
case"/"=>p(y,u(1)/u(0)::a)
case d=>p(y,d.toDouble::u)}}}
println(p((readLine()split " ").toList,Nil))}
```
[Answer]
# Python - 206
```
import sys;i=sys.argv[1].split();s=[];a=s.append;b=s.pop
for t in i:
if t=="+":a(b()+b())
elif t=="-":m=b();a(b()-m)
elif t=="*":a(b()*b())
elif t=="/":m=b();a(b()/m)
else:a(float(t))
print(b())
```
Ungolfed version:
```
# RPN
import sys
input = sys.argv[1].split()
stack = []
# Eval postfix notation
for tkn in input:
if tkn == "+":
stack.append(stack.pop() + stack.pop())
elif tkn == "-":
tmp = stack.pop()
stack.append(stack.pop() - tmp)
elif tkn == "*":
stack.append(stack.pop() * stack.pop())
elif tkn == "/":
tmp = stack.pop()
stack.append(stack.pop()/tmp)
else:
stack.append(float(tkn))
print(stack.pop())
```
Input from command-line argument; output on standard output.
[Answer]
# ECMAScript 6 (131)
Just typed together in a few seconds, so it can probably be golfed further or maybe even approached better. I might revisit it tomorrow:
```
f=s=>(p=[],s.split(/\s+/).forEach(t=>+t==t?p.push(t):(b=+p.pop(),a=+p.pop(),p.push(t=='+'?a+b:t=='-'?a-b:t=='*'?a*b:a/b))),p.pop())
```
[Answer]
## C# - 323 284 241
```
class P{static void Main(string[] i){int x=0;var a=new float[i.Length];foreach(var s in i){var o="+-*/".IndexOf(s);if(o>-1){float y=a[--x],z=a[--x];a[x++]=o>3?z/y:o>2?z*y:o>1?z-y:y+z;}else a[x++]=float.Parse(s);}System.Console.Write(a[0]);}}
```
Edit: Replacing the Stack with an Array is way shorter
Edit2: Replaced the ifs with a ternary expression
[Answer]
# Python 2
I've tried out some different approaches to the ones published so far. None of these is quite as short as the best Python solutions, but they might still be interesting to some of you.
## Using recursion, 146
```
def f(s):
try:x=s.pop();r=float(x)
except:b,s=f(s);a,s=f(s);r=[a+b,a-b,a*b,b and a/b]['+-*'.find(x)]
return r,s
print f(raw_input().split())[0]
```
## Using list manipulation, 149
```
s=raw_input().split()
i=0
while s[1:]:
o='+-*/'.find(s[i])
if~o:i-=2;a,b=map(float,s[i:i+2]);s[i:i+3]=[[a+b,a-b,a*b,b and a/b][o]]
i+=1
print s[0]
```
## Using `reduce()`, 145
```
print reduce(lambda s,x:x in'+-*/'and[(lambda b,a:[a+b,a-b,a*b,b and a/b])(*s[:2])['+-*'.find(x)]]+s[2:]or[float(x)]+s,raw_input().split(),[])[0]
```
[Answer]
## Matlab, 228
```
F='+-/*';f={@plus,@minus,@rdivide,@times};t=strsplit(input('','s'),' ');i=str2double(t);j=~isnan(i);t(j)=num2cell(i(j));while numel(t)>1
n=find(cellfun(@(x)isstr(x),t),1);t{n}=bsxfun(f{t{n}==F},t{n-2:n-1});t(n-2:n-1)=[];end
t{1}
```
Ungolfed:
```
F = '+-/*'; %// possible operators
f = {@plus,@minus,@rdivide,@times}; %// to be used with bsxfun
t = strsplit(input('','s'),' '); %// input string and split by one or multiple spaces
i = str2double(t); %// convert each split string to number
j =~ isnan(i); %// these were operators, not numbers ...
t(j) = num2cell(i(j)); %// ... so restore them
while numel(t)>1
n = find(cellfun(@(x)isstr(x),t),1); %// find left-most operator
t{n} = bsxfun(f{t{n}==F}, t{n-2:n-1}); %// apply it to preceding numbers and replace
t(n-2:n-1)=[]; %// remove used numbers
end
t{1} %// display result
```
[Answer]
# K5, 70 bytes
```
`0:*{$[-9=@*x;((*(+;-;*;%)@"+-*/"?y).-2#x;x,.y)@47<y;(.x;.y)]}/" "\0:`
```
I'm not sure when K5 was released, so this *might* not count. Still awesome!
] |
[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/53452/edit).
Closed 8 years ago.
[Improve this question](/posts/53452/edit)
C++ implements a Turing-complete functional programming language which is evaluated at compile time.
Hence, we can use a C++ compiler as an interpreter to run our metaprogram without ever generating code. Unfortunately, `static_assert` won't allow us to emit our result at compile-time, so we do need\* to generate an executable to display the result.
\* we can display via a compile-time error in template instantiation, but the result is less readable.
# Challenge
Implement a useful or impressive program purely via template metaprogramming. This is a popularity contest, so the code with the most votes wins.
Rules:
1. Your program must compile against the C++14 standard. This means that the actual compiler you use doesn't matter to anyone else.
`-std=c++14`
2. "External" input is passed via preprocessor definitions.
`-Dparam=42`
3. Output is via a single `cout`/`printf` line which does no run-time calculations besides those necessary for stringifying the result, or is via a compile-time error.
`int main(int argc, char **argv) {
std::cout << MyMetaProgram<param>::result << std::endl;
}`
---
# Example: Factorial
### bang.h
```
template <unsigned long long N>
struct Bang
{
static constexpr unsigned long long value = N * Bang<N-1>::value;
};
template <>
struct Bang<0>
{
static constexpr unsigned long long value = 1;
};
```
### bang.cpp
```
#include <iostream>
#include "bang.h"
int main(int argc, char **argv)
{
std::cout << Bang<X>::value << std::endl;
}
```
### execute
```
$ g++ -std=c++14 -DX=6 bang.cpp -o bang && ./bang
120
```
]
|
[Question]
[
Your function or program should take a year as input and return (or print) the date (in the Gregorian calendar) of that years Easter (not the Eastern Orthodox Easter). The date returned should be formatted according to ISO 8601, but with support for years greater than 9999 (such as *312013-04-05* or *20010130*), and it only needs to work with years greater than or equal to **1583** (the year of the adoption of the Gregorian calendar), and years less than or equal to **5701583** (as that is when the sequence of Easter dates starts to repeat itself).
Examples:
```
e(5701583) = 5701583-04-10
e(2013) = 2013-03-31
e(1583) = 1583-04-10
e(3029) = 30290322
e(1789) = 17890412
e(1725) = 17250401
```
The use of built-in functions for returning the date of easter is boring and therefore disallowed. Shortest answer (in characters) wins.
*Resources:*
* *<http://en.wikipedia.org/wiki/Computus#Algorithms>*
* *<http://web.archive.org/web/20150227133210/http://www.merlyn.demon.co.uk/estralgs.txt>*
[Answer]
## GolfScript (85 chars)
```
~:^100/.)3*4/.@8*13+25/-^19%.19*15+@+30%.@11/+29/23--.@-^.4/++7%97--^[[email protected]](/cdn-cgi/l/email-protection)/100*\31%)+
```
Sample usage:
```
$ golfscript.rb codegolf11132.gs <<<2013
20130331
```
Note that this uses a different algorithm to most of the current answers. To be specific, I've adapted the algorithm attributed to Lichtenberg in the resource linked by [Sean Cheshire](https://codegolf.stackexchange.com/users/5011/sean-cheshire) in a comment on the question.
The original algorithm, assuming sensible types (i.e. not JavaScript's numbers) and with an adaptation to give month\*31+day (using day offset of 0) is
```
K = Y/100
M = 15 + (3*K+3)/4 - (8*K+13)/25
S = 2 - (3*K+3)/4
A = Y%19
D = (19*A+M) % 30
R = (D + A/11)/29
OG = 21 + D - R
SZ = 7 - (Y + Y/4 + S) % 7
OE = 7 - (OG-SZ) % 7
return OG + OE + 92
```
I extracted a common subexpression and did some other optimisations to reduce to
```
K = y/100
k = (3*K+3)/4
A = y%19
D = (19*A+15+k-(8*K+13)/25)%30
G = 23+D-(D+A/11)/29
return 97+G-(G+y+y/4-k)%7
```
This approach has slightly more arithmetic operations than the other one (Al Petrofsky's 20-op algorithm), but it has smaller constants; GolfScript doesn't need to worry about the extra parentheses because it's stack-based, and since each intermediate value in my optimised layout is used precisely twice it fits nicely with GolfScript's limitation of easy access to the top three items on the stack.
[Answer]
# Python 2 - 125 120 119 chars
This is [Fors's answer](https://codegolf.stackexchange.com/a/11146/2621) shamelessly ported to Python.
```
y=input()
a=y/100*1483-y/400*2225+2613
b=(y%19*3510+a/25*319)/330%29
b=148-b-(y*5/4+a-b)%7
print(y*100+b/31)*100+b%31+1
```
**Edit**: Changed last line from `print"%d-0%d-%02d"%(y,b/31,b%31+1)` to save 5 characters. I would have loved to represent `10000` as `1e4`, but that would produce floating point necessitating a call to `int`.
**Edit2**:
Thanks to Peter Taylor for showing how to get rid of that `10000` and save 1 character.
[Answer]
# PHP 154
**150** chars if I switch to YYYYMMDD instead of YYYY-MM-DD.
```
<?$y=$argv[1];$a=$y/100|0;$b=$a>>2;$c=($y%19*351-~($b+$a*29.32+13.54)*31.9)/33%29|0;$d=56-$c-~($a-$b+$c-24-$y/.8)%7;echo$d>31?"$y-04-".($d-31):"$y-03-$d";
```
With Line Breaks:
```
<?
$y = $argv[1];
$a = $y / 100 |0;
$b = $a >> 2;
$c = ($y % 19 * 351 - ~($b + $a * 29.32 + 13.54) * 31.9) / 33 % 29 |0;
$d = 56 - $c - ~($a - $b + $c - 24 - $y / .8) % 7;
echo $d > 31 ? "$y-04-".($d - 31) : "$y-03-$d";
```
Useage: `php easter.php 1997`
Output: `1997-03-30`
Useage: `php easter.php 2001`
Output: `2001-04-15`
[Answer]
# dc: 106 characters
```
?[0n]smdndsy100/1483*ly400/2225*-2613+dsa25/319*ly19%3510*+330/29%sb148lb-5ly*4/la+lb-7%-d31/0nn31%1+d9>mp
```
Usage:
```
> dc -e "?[0n]smdndsy100/1483*ly400/2225*-2613+dsa25/319*ly19%3510*+330/29%sb148lb-5ly*4/la+lb-7%-d31/0nn31%1+d9>mp"
1725
17250401
>
```
This should be able to be shortened by using 'd' and 'r' instead of all the loads and stores.
[Answer]
# C: 151 148 characters
```
y;a;b;main(){scanf("%d",&y);a=y/100*1483-y/400*2225+2613;b=(y%19*3510+a/25*319)/330%29;b=148-b-(y*5/4+a-b)%7;printf("%d-0%d-%02d\n",y,b/31,b%31+1);}
```
And the same code, but better formatted:
```
#include <stdio.h>
int y, a, b;
int main() {
scanf("%d", &y);
a = y/100*1483 - y/400*2225 + 2613;
b = (y%19*3510 + a/25*319)/330%29;
b = 148 - b - (y*5/4 + a - b)%7;
printf("%d-0%d-%02d\n", y, b/31, b%31 + 1);
}
```
There are frightfully many algorithms for calculating the date of Easter, but only a few of them are well suited for code golfing.
[Answer]
# Javascript 162 156 145
```
function e(y){alert(y+"0"+((d=56-(c=(y%19*351-~((b=(a=y/100|0)>>2)+a*29.32+13.54)*31.9)/33%29|0)-~(a-b+c-24-y/.8)%7)>(f=31)?4:3)+(d-f>0&d-f<10?0:"")+(d>f?d-f:d))}
```
Inspired by @jdstankosky's PHP solution...
Provides YYYYMMDD result...
Now narrowed down to:
```
alert((y=prompt())+0+((d=56-(c=(y%19*351-~((b=(a=y/100|0)>>2)+a*29.32+13.54)*31.9)/33%29|0)-~(a-b+c-24-y/.8)%7)>(f=31)?4:3)+(d-f>0&d-f<10?0:"")+(d>f?d-f:d))
```
Now asks for input... reduced literal string of "0" to 0 and let loose typing work to my advantage! :)
Reduced further to take ES6 into account...
`e=y=>y+"0"+((d=56-(c=(y%19*351-31.9*~((b=(a=y/100|0)>>2)+29.32*a+13.54))/33%29|0)-~(a-b+c-24-y/.8)%7)>(f=31)?4:3)+(d-f>0&d-f<10?0:"")+(d>f?d-f:d)`
[Answer]
## APL 132
This algorithm calculates the number of days Easter lies relative to the beginning of March. The date is returned in the YYYYMMDD format as allowed in the question:
```
E y
(a b)←⌊((3 8×⌊y÷100)+¯5 13)÷4 25
c←7|y+(⌊y÷4)-a-e←⌊d-((19×d←30|(227-(11×c)-a-b))+c←19|y)÷543
+/(10*4 2 0)×y,(3+i>31),(61⍴⍳31)[i←e+28-c]
```
Taking the original test cases:
```
E 2013
20130331
E 1583
15830410
E 3029
30290322
E 1789
17890412
```
[Answer]
# Javascript 134 Characters
Using a slightly modified Al Petrofsky's 20-op algorithm to allow a simpler conversion into the year-month-date format.
This provides additional 14 characters shorter code from the answer provided by [WallyWest](https://codegolf.stackexchange.com/users/8555/wallywest)
## The Original Al Petrofsky's Code:
```
a =Y/100|0,
b =a>>2,
c =(Y%19*351-~(b+a*29.32+13.54)*31.9)/33%29|0,
d =56-c-~(a-b+c-24-Y/.8)%7;
```
Last line changed to:
```
d =148-c-~(a-b+c-24-Y/.8)%7;
```
## 1. 138 Characters With the format YYYY-MM-DD
```
e=y=>(c=(y%19*351-31.9*~((b=(a=y/100|0)>>2)+29.32*a+13.54))/33%29|0,d=148-c-~(a-b+c-24-y/.8)%7,y+'-0'+(d/31|0)+"-"+((o=d%31+1)>9?o:'0'+o))
console.log(e(2021));
console.log(e(2022));
console.log(e(5701583));
console.log(e(2013));
console.log(e(1583));
console.log(e(3029));
console.log(e(1789));
console.log(e(1725));
```
## 2. 134 Characters With the format YYYYMMDD
```
e=y=>(c=(y%19*351-31.9*~((b=(a=y/100|0)>>2)+29.32*a+13.54))/33%29|0,d=148-c-~(a-b+c-24-y/.8)%7,y+'0'+(d/31|0)+((d=d%31+1)>9?d:'0'+d))
console.log(e(2021));
console.log(e(2022));
console.log(e(5701583));
console.log(e(2013));
console.log(e(1583));
console.log(e(3029));
console.log(e(1789));
console.log(e(1725));
```
[Answer]
# [Fortran (GFortran)](https://gcc.gnu.org/fortran/), 179 bytes
```
READ*,I
J=I/100*2967-I/400*8875+7961
K=MOD(MOD(I,19)*6060+(MOD(MOD(J/25,59),30)+23)*319-1,9570)/330
L=K+28-MOD(I*5/4+J+K,7)
WRITE(*,'(I7,I0.2,I0.2)')I,(L-1)/31+3,MOD(L-1,31)+1
END
```
[Try it online!](https://tio.run/##NYvBDoIwEETv/RG67dbutpbSAwcTOBRQE2Li2QveNCH@PwLGw0zeTPKm9/yZHy/znH6wLGN7ahRm0dXZMpFyqYwm2@OKVRWDjqlk0dfnayO3ZOQEqqSStPx/nXUBQwL0BNp5UJ6TYUwhEljvSQx1r11ldl8Fe9Sd7jGCuI/51kqFhcwRMx3cXlBARjkYXmXWHjdtXegZNIv20iyLI66@ "Fortran (GFortran) – Try It Online")
Uses the "Emended Gregorian Easter" algorithm (Al Petrofsky) from the second resource link. Strangely, it fails for year 5701583 (and, apparently, only for this year), predicting the Easter as one week earlier. Prints the date in `YYYYYYYMMDD` format, with some leading spaces if the year has less then seven digits.
] |
[Question]
[
Okay, I recently wrote a Javascript Rubik's Cube scrambler that outputs a 25-move scramble. It's 135 bytes. The Gist is [here](https://gist.github.com/molarmanful/2f299ae96f6120cf5283), but for reference, I have the formatted code:
```
function(){
for(a=s=y=r=[],m='RLUDFB',x=Math.random;++a<26;y=r,s.push(r+["'",2,''][0|x()*2]))
for(;r==y;r=m[0|x()*5]);
return s.join(' ')
}
```
Any tips?
EDIT: Code is updated, with @Optimizer's edits.
[Answer]
# ~~140 135~~ 127 bytes
Still a big one, but here's for starters:
```
function(){for(a=s=y=r=[],x=Math.random;a<25;s[a++]=r+["'",2,''][0|x(y=r)*3])for(;r==y;r='RLUDFB'[0|x()*6]);return s.join(' ')}
```
Some of the few tips used:
* Loose the `var`. There is no point in using `var` when your aim is to golf!
* When `a = []`, `a++` gives `0`. We use this fact to remove a `0` and `,`
* Combine the `a<25` and `a++`
* You don't need to split a string. You can access its characters anyways via `[i]`
* Get rid of `{}` in `for` loops
More to come.
] |
[Question]
[
**This question already has answers here**:
[Just Another Polyglot Hacker! [duplicate]](/questions/16853/just-another-polyglot-hacker)
(5 answers)
[Write a polyglot that prints the language's name](/questions/7261/write-a-polyglot-that-prints-the-languages-name)
(17 answers)
Closed 8 years ago.
A polyglot is a program which can be run by several different language's interpreters/compilers without failing.
For example, [the stackoverflow 404 page](https://stackoverflow.com/forty-two) contains a polyglot which runs in Python, Perl, Ruby, C, brainfuck and befunge, each time printing 404 to stdout.
Now, my challenge is to create a polyglot which, when run as a certain language, will print:
>
> Just Another #{Name Of Language} Hacker,
>
>
>
So, if you say that your program can be run as both JavaScript and ><>, when run in a JavaScript environment it should print
```
Just Another JavaScript Hacker,
```
and when run by a ><> interpreter,
```
Just Another ><> Hacker,
```
In your answers, you should list the number of languages which accept it as a valid program and produce correct output, as well as a list of those languages.
The program which runs under the most languages wins!
]
|
[Question]
[
# Task
Given a list of space-delimited integers as input, output all unique non-empty subsets of these numbers that each subset sums to 0.
---
## Test Case
Input: `8 −7 5 −3 −2`
Output: `-3 -2 5`
---
## Winning Criterion
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins!
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog) (2), 9 characters
```
{⊇.+0∧}ᵘb
```
[Try it online!](https://tio.run/nexus/brachylog2#@1/9qKtdT9vgUcfy2odbZyT9/x9toRNvrmOqE2@sE2@kYxL7PwoA "Brachylog – TIO Nexus")
```
{⊇.+0∧}ᵘb
⊇ subset
+0 that sums to 0
. ∧ output the subset
{ }ᵘ take all unique solutions
b except the first (which is the empty solution)
```
[Answer]
### GolfScript, 41 characters
```
~][[]]\{`{1$+$}+%}%;(;.&{{+}*!},{" "*}%n*
```
If you do not care about the specific output format you can shorten the code to 33 characters.
```
~][[]]\{`{1$+$}+%}%;(;.&{{+}*!},`
```
Example (see [online](http://golfscript.apphb.com/?c=OyI4IC03IDUgLTMgLTIgNCIKCn5dW1tdXVx7YHsxJCskfSslfSU7KDsuJnt7K30qIX0seyIgIip9JW4qCgpwcmludA%3D%3D)):
```
> 8 -7 5 -3 -2 4
-3 -2 5
-7 -2 4 5
-7 -3 -2 4 8
```
[Answer]
## Python, 119 chars
```
def S(C,L):
if L:S(C,L[1:]);S(C+[L[0]],L[1:])
elif sum(map(int,C))==0and C:print' '.join(C)
S([],raw_input().split())
```
Enumerates all 2^n subsets recursively and checks each one.
[Answer]
## Python, 120
I'm a character worse than Keith's solution. But... this is too close to not post. One of my favorite features of code-golf is how dissimilar similar-length solutions can be.
```
l=raw_input().split()
print[c for c in[[int(j)for t,j in enumerate(l)if 2**t&i]for i in range(1,2**len(l))]if sum(c)==0]
```
[Answer]
## Python (~~128 137~~ 136)
Damn you, `itertools.permutations`, for having such a long name!
Brute force solution. I'm surprised it's not the shortest: but I guess `itertools` ruins the solution.
Ungolfed:
```
import itertools
initial_set=map(int, input().split())
ans=[]
for length in range(1, len(x)+1):
for subset in itertools.permutations(initial_set, length):
if sum(subset)==0:
ans+=str(sorted(subset))
print set(ans)
```
Golfed (ugly output):
```
from itertools import*
x=map(int,input().split())
print set(`sorted(j)`for a in range(1,len(x)+1)for j in permutations(x,a)if sum(j)==0)
```
Golfed (pretty output) (183):
```
from itertools import*
x=map(int,input().split())
print `set(`sorted(j)`[1:-1]for a in range(1,len(x)+1)for j in permutations(x,a)if sum(j)==0)`[5:-2].replace("'","\n").replace(",","")
```
`import itertools as i`: importing the itertools module and calling it `i`
`x=map(int,input().split())`: seperates the input by spaces, then turns the resulting lists' items into integers (`2 3 -5` -> `[2, 3, -5]`)
set(`sorted(j)`for a in range(1,len(x)+1)for j in i.permutations(x,a)if sum(j)==0):
Returns a list of all subsets in `x`, sorted, where the sum is 0, and then gets only the unique items
(`set(...)`)
The graves (`) around `sorted(j)` is Python shorthand for `repr(sorted(j))`. The reason why this is here is because sets in Python cannot handle lists, so the next best thing is to use strings with a list as the text.
[Answer]
## C# – 384 characters
OK, functional-style programming in C# is not that *short*, but I *love* it! (Using just a brute-force enumeration, nothing better.)
```
using System;using System.Linq;class C{static void Main(){var d=Console.ReadLine().Split(' ').Select(s=>Int32.Parse(s)).ToArray();foreach(var s in Enumerable.Range(1,(1<<d.Length)-1).Select(p=>Enumerable.Range(0,d.Length).Where(i=>(p&1<<i)!=0)).Where(p=>d.Where((x,i)=>p.Contains(i)).Sum()==0).Select(p=>String.Join(" ",p.Select(i=>d[i].ToString()).ToArray())))Console.WriteLine(s);}}
```
Formatted and commented for more readability:
```
using System;
using System.Linq;
class C
{
static void Main()
{
// read the data from stdin, split by spaces, and convert to integers, nothing fancy
var d = Console.ReadLine().Split(' ').Select(s => Int32.Parse(s)).ToArray();
// loop through all solutions generated by the following LINQ expression
foreach (var s in
// first, generate all possible subsets; well, first just their numbers
Enumerable.Range(1, (1 << d.Length) - 1)
// convert the numbers to the real subsets of the indices in the original data (using the number as a bit mask)
.Select(p => Enumerable.Range(0, d.Length).Where(i => (p & 1 << i) != 0))
// and now filter those subsets only to those which sum to zero
.Where(p => d.Where((x, i) => p.Contains(i)).Sum() == 0)
// we have the list of solutions here! just convert them to space-delimited strings
.Select(p => String.Join(" ", p.Select(i => d[i].ToString()).ToArray()))
)
// and print them!
Console.WriteLine(s);
}
}
```
[Answer]
# **SWI-Prolog** 84
This version prints the list, instead of trying to find an appropriate binding for a term in a predicate.
```
s([],O):-O=[_|_],sum_list(O,0),print(O).
s([H|T],P):-s(T,[H|P]).
s([_|T],O):-s(T,O).
```
### Input method
```
s([8,-7,5,-3,-2,4],[]).
```
---
For the record, this is the version that finds a binding to satisfy the predicate:
```
s(L,O):-s(L,0,O),O=[_|_].
s([],0,[]).
s([H|T],S,[H|P]):-R is H+S,s(T,R,P).
s([_|T],S,O):-s(T,S,O).
```
### Input method
```
s([8,-7,5,-3,-2,4],O).
```
Previous revision contains an incomplete solution that didn't manage to remove empty set.
[Answer]
# Mathematica 62 57 38
**Code**
Input entered as integers in an array, `x`.
```
x
```
```
Grid@Select[Subsets@x[[1, 1]], Tr@# == 0 &]
```
---
**Output**
---
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
ŒPḊSÐḟ
```
[Try it online!](https://tio.run/##y0rNyan8///opICHO7qCD094uGP@////LXR0zXVMdXSNdXSNAA "Jelly – Try It Online")
Just for completeness. Similar to Brachylog, Jelly also postdates the challenge, but by now, newer languages compete normally.
```
ŒP Power set.
Ḋ Dequeue, remove the first element (empty set).
Ðḟ Filter out the subsets with truthy (nonzero)...
S sum.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
æ¦ʒO>
```
[Try it online!](https://tio.run/##MzBNTDJM/f//8LJDy05N8rf7/z/aQkfXXMdUR9dYR9coFgA "05AB1E – Try It Online")
---
If input must be space delimited, prepending `#` to this answer is the only change required.
[Answer]
## J, 57 53 51 49 characters
```
>a:-.~(#:@i.@(2&^)@#<@":@(#~0=+/)@#"1 _])".1!:1[1
```
Usage:
```
>a:-.~(#:@i.@(2&^)@#<@":@(#~0=+/)@#"1 _])".1!:1[1
8 _7 5 _3 _2 4
5 _3 _2
_7 5 _2 4
8 _7 _3 _2 4
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)CP437
```
â±3╒yΣ╓à
```
[Run and debug online!](https://staxlang.xyz/#c=%C3%A2%C2%B13%E2%95%92y%CE%A3%E2%95%93%C3%A0&i=8+-7+5+-3+-2&a=1)
## Explanation
Uses the unpacked version (9 bytes) to explain.
```
LS{|+!fmJ
L Convert to list
S Powerset
{ f Filter with block
|+! Sum is zero
mJ Print each subset, joined by spaces
```
[Answer]
# [J](http://jsoftware.com/), 34 bytes
```
(a:-.~](<@#~0=+/)@#~[:#:@i.2^#)@".
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NRKtdPXqYjVsHJTrDGy19TWBdLSVspVDpp5RnLKmg5Lef02u1OSMfAUNG1OFeGOFeCNNBVuFNAV1C4V4cwWokDpUCZBrag0TtFawADNMwQxzoIiCGZCnqaBrha4fLKH@HwA "J – Try It Online")
## how
`".` converts the input to a list. then:
```
a: -.~ ] (<@#~ (0 = +/))@#~ [: #:@i. 2 ^ #
i. NB. ints from 0 to...
2 ^ # NB. 2 to the input len
[: #:@ NB. converted to binary masks
] ( ) #~ NB. filter the input using
NB. using those masks, giving
NB. us all subsets
( )@ NB. and to each one...
( #~ (0 = +/)) NB. return it if its sum is
NB. 0, otherwise make it
NB. the empty list.
(<@ ) NB. and box the result.
NB. now we have our answers
NB. and a bunch of empty
NB. boxes, or aces (a:).
a: -.~ NB. remove the aces.
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 51 bytes
```
*.words.combinations.skip.grep(!*.sum)>>.Bag.unique
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwX0uvPL8opVgvOT83KTMvsSQzP69Yrzg7s0AvvSi1QENRS6@4NFfTzk7PKTFdrzQvs7A09b81V3FipUKahpKFgq65gqmCrrGCrpGCiZImXMIYJAYigGL/AQ "Perl 6 – Try It Online")
Returns a list of unique Bags that sum to 0. A Bag is a weighted Set.
### Explanation:
```
*.words # Split by whitespace
.combinations # Get the powerset
.skip # Skip the empty list
.grep(!*.sum) # Select the ones that sum to 0
>>.Bag # Map each to a weighted Set
.unique # And get the unique sets
```
[Answer]
# Ruby, 110 bytes
```
a=gets.split.map &:to_i;b=[];(1...a.length).each{|c|a.permutation(c){|d|d.sum==0?b<<d:0}};p b.map(&:sort).uniq
```
Will add TIO link later.
Takes input from stdin as a list of numbers, e.g. `8 −7 5 −3 −2`
How it works: It converts the input into an array of numbers. Gets all the permutations of the lengths from 1 to the array's length. It adds them to the output array if they sum to 0. It outputs the array without duplicates.
Output for the sample input: `[[-3, -2, 5]]`
] |
[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/19196/edit).
Closed 3 years ago.
The community reviewed whether to reopen this question 8 months ago and left it closed:
>
> Original close reason(s) were not resolved
>
>
>
[Improve this question](/posts/19196/edit)
Given two arbitrary numbers A,B. Print number B as a Digital LED Pattern where A is the scale.
input:
```
1 2320451640799518
```
ouput:
```
_ _ _ _ _ _ _ _ _ _ _ _
_| _| _|| ||_||_ ||_ |_|| | ||_||_||_ ||_|
|_ _||_ |_| | _| ||_| ||_| | | | _| ||_|
```
input:
```
2 23
```
ouput:
```
__ __
| |
__| __|
| |
|__ __|
```
**Rules:**
* Use **STDIN/STDOUT** for **input/output**
* Code with most up-votes wins. In case of Tie, shortest code will be accepted
* Most up voted Answer will be accepted at 01/02/2014 (Accepted [this answer](https://codegolf.stackexchange.com/questions/19196/transform-number-into-7-segment-display-pattern/19269#19269) with highest 12 votes)
[Answer]
# Commodore 64 BASIC
[PETSCII](http://en.wikipedia.org/wiki/PETSCII) art rules :)
Output:
[Answer]
# Python 3, ~~286 282~~ 280
Yeah I golfed this one. Nice challenge!
```
n,x=input().split()
n=int(n)
l=lambda s:"".join(s)+"\n"
h=lambda s:s.replace(*"! ")*~-n+s.replace(*"!_")
print(l(" "+"_ "[c in"14"]*n+" "for c in x)+h(l("| "[c in"1237"]+n*"! "[c in"017"]+"| "[c in"56"]for c in x))+h(l(" |"[c in"0268"]+n*"! "[c in"1479"]+"| "[c=="2"]for c in x)))
```
---
Also, here's a Python 2 version weighing in at only 273 bytes!
Not updating this one any more with further golfed original source. This was created when the original source was 282 bytes (Python 3 version).
```
exec'eJxdzE0OgjAQhuE9pxhn1VIlFhHUpCdRQlAx1NShAYwsOLzgD4irSd758tC8UWX6SDTZe824V1mju+uQ0lQz4o5RJr0dzylUO0TvWmhiFRd4IHTy8VV5ZWZNesqYizNA7jJaSC4mOUHu2LJjwTAEFJgA7k+gCWWAsUuii5eihD5Bw0XOul07bPxVhLGgl/9OS9mXcbIOMf4BPgK037kfbv4EGUTbgVAK/SnwBAs+TpU='.decode('base64').decode('zip')
```
This may be cheating, so I'm adding it separately. Let me know whether this is considered valid or not.
[Answer]
## Haskell (389 chars)
The solution uses 7 arrays, one for each segment of the array, using the names from this image:
. The value `a !! 4` will be the character that should be displayed at that a position for the number 4.
The values are multiplied by the scale where appropriate (using `r` and `rp` for replication), and finally printed out.
### The code
```
a="_ __ _____"
b="||||| |||"
c="|| |||||||"
d="_ __ __ _ "
e="| | | | "
f="| ||| ||"
g=" _____ __"
r=replicate
cm=concatMap
s=(' ':).(++" ")
dd w n=[[t n],rp$m f b n,[o g f b n],rp$m e c n,[o d e c n]] where
rp=r$w-1
t=cm(s.r w.(a!!))
q f s x y=cm(\n->x!!n:r w(f s n)++[y!!n])
o=q(!!)
m=q const ' '
go a=unlines$concat$dd(read$a!!0)$map(read.(:[]))$a!!1
main=interact$go.words
```
## Example usage
```
echo '1 2320451640799518' | runhaskell ./digit_led.hs
_ _ _ _ _ _ _ _ _ _ _ _
_| _| _|| ||_||_ ||_ |_|| | ||_||_||_ ||_|
|_ _||_ |_| | _| ||_| ||_| | | | _| ||_|
```
[Answer]
# C, 249 226 chars
Golfed solution in C:
```
int x,y,g,s,q;main(){char*c,i[99];for(scanf("%d %98s",&s,i);y<2*s+1;++y,puts(""))for(c=i;*c;++c)for(x=0;x<s+2;++x)q=(y+s-1)/s*3+(x+s-1)/s,g=(x%(s+1))*(y%s)?7:q<3?~q%2*7:q-2,putchar("_|_||_| "["zG<lMfvH~N"[*c-48]+1>>g&1?g:7]);}
```
With added whitespace:
```
int x, y, g, s, q;
main() {
char *c, i[99];
for (scanf("%d %98s", &s, i); y < 2 * s + 1; ++y, puts(""))
for (c = i; *c; ++c)
for (x = 0; x < s + 2; ++x)
q = (y + s - 1) / s * 3 + (x + s - 1) / s,
g = (x % (s + 1)) * (y % s)
? 7
: q < 3
? ~q % 2 * 7
: q - 2,
putchar("_|_||_| "["zG<lMfvH~N"[*c - 48] + 1 >> g & 1 ? g : 7]);
}
```
Notes:
* At most 99 digits are printed
* Behavior is undefined if the input is not well formed (e.g. contains non-digits, or scale is < 1)
* Should be legal C89 code
I will provide an explanation of how it works, should anyone care.
[Answer]
# Ruby 2.0
Quick and (not so) naive ruby implementation.
```
V,H = ' |',' _'
l = gets.split
s = l[0].to_i
o = Array.new 1+s*2, ''
l[1].each_char {|c|
m = "{H=mNgwI\x7FO"[c.to_i].ord
o[0] += " #{H[m[0]]*s} "
o[s] += "#{V[m[1]]}#{H[m[2]]*s}#{V[m[3]]}"
o[s*2] += "#{V[m[4]]}#{H[m[5]]*s}#{V[m[6]]}"
}
(s-1).times { |i|
o[i+1] = o[s].gsub '_', ' '
o[s+i+1] = o[s*2].gsub '_', ' '
}
o.each {|r| puts r}
```
Quick explanation:
I first declare the strings representing on and off digits for horizontal and vertical bars.
Then I read scale and the digits.
I then declare an array of the necessary size to store enough lines for the given scale.
The weird string is actually a mapping of 7-bits values representing which LEDs to switch on for each digit.
Next, for each digit, I fill the output array from top to bottom, taking into account horizontal scaling.
The final loop is to fill the rows that only have vertical bars, which can just be generated from the middle and bottom rows by removing horizontal bars.
Finally, I print the output array !
[Answer]
Python 2.6 with no imports. I'd say that the attractiveness of this solution is the use of templates. Unfortunately I think that's why I had such a hard time compacting it.
```
def numbers(scale, number):
def single(yay, wall, digit):
walls = ('1110111', '0010010', '1011101', '1011011',
'0111010', '1101011', '1101111',
'1010010', '1111111',
'1111010')
return yay if int(walls[digit][wall]) else ' '
def expand_one(char, digit):
characters = '_||_||_'
translated = single(characters[char], char, digit)
if char % 3:
return translated
return translated * scale
def expand_template(template, digit):
out = ''
for c in template:
if c == '.':
out += ' ' * scale
elif c == ' ':
out += c
else:
out += expand_one(int(c), digit)
return out
def repeated_expand_template(template, n):
print ''.join(expand_template(template, int(d)) for d in n)
repeated_expand_template(' 0 ', number)
for _ in range(scale - 1):
repeated_expand_template('1.2', number)
repeated_expand_template('132', number)
for _ in range(scale - 1):
repeated_expand_template('4.5', number)
repeated_expand_template('465', number)
scale, number = raw_input().split()
numbers(int(scale), number)
```
And a bit shorter (308 characters):
```
s,n=raw_input().split();s=int(s)
for e in('0 0 ','11.2','0132','14.5','0465'):print '\n'.join(''.join(''.join(([' ','_||_||_'[int(c)]][int(bin(1098931065668123279354)[7*int(d)+int(c)+2])]*(s,1,1)[int(c)%3])if ord(c)>46 else c for c in e[1:].replace('.',' '*s))for d in n) for _ in range((1,s-1)[int(e[0])]))
```
[Answer]
(Edit: This solution is now invalid because the semantics of the `銻` instruction has changed. I didn’t realise that I’d already made use of the instruction when I changed it. You can, however, fix ths program by simply changing it to the newer instruction `壹`.)
# ~~[Sclipting](http://esolangs.org/wiki/Sclipting) — 85 characters~~
```
겠合글坼銻標⓷가殲갰復묽땸민뫝뜵깉걈밂⓶各가⓵겐上⓷감嚙긇밌⓶掘⓶감嚙눖밂⓶掘⓷合⓶감嚙긇밌⓶掘⓷合⓸⓸替❶終⓶丟終❶눠替눐終①貶復⓶⓷終丟併눐替글①復終눠替뇰①復終⓶丟
```
---
①
## Input:
```
1 1024856359701
```
## Output:
```
_ _ _ _ _ _ _ _ _ _
|| | _||_||_||_ |_ _||_ |_| || | |
||_||_ ||_| _||_| _| _| | ||_| |
```
---
②
## Input:
```
2 47474747
```
## Output:
```
__ __ __ __
| | || | || | || | |
|__| ||__| ||__| ||__| |
| | | | | | | |
| | | | | | | |
```
[Answer]
# C# (480 443 chars)
```
namespace System{using z=String;using w=Console;class P{static void Main(){var t=w.ReadLine().Split(' ');var s=int.Parse(t[0]);z b="17",d=b+23,e=b+3459,f="56",g=e+2680;Action<z,z,z,int>q=(l,m,r,n)=>{for(int i=1;i<n;i++){foreach(var c in t[1]){h(c,l);for(int j=0;j<s;j++)h(c,m,"_");h(c,r);}w.Write("\n");}};q(g,"14",g,2);q(d,g,f,s);q(d,b+0,f,2);q(e,g,"2",s);q(e,b+49,"2",2);}static void h(char x,z m,z y="|"){w.Write(m.Contains(""+x)?" ":y);}}}
```
Extended version:
```
using System;
using System.Linq;
namespace Segments
{
internal class Program
{
static void Main()
{
var scale = int.Parse(Console.ReadLine());
var input = Console.ReadLine();
PrintLine(input, "", "14", "", 2);
PrintLine(input,"1237", "", "56", scale);
PrintLine(input,"1237", "170", "56", 2);
PrintLine(input,"134579", "", "2", scale);
PrintLine(input,"134579", "147", "2", 2);
}
static void PrintLine(string input, string leftMatch, string middleMatch, string rightMatch, int scale)
{
for (int i = 1; i < scale; i++)
{
foreach (var c in input)
{
PrintDigitLine(c, leftMatch, '|', 1);
PrintDigitLine(c, middleMatch, "_", scale);
PrintDigitLine(c, rightMatch, '|', 1);
}
Console.Write("\n");
}
}
private static void PrintDigitLine(char digit, string match, char charToPrint, int)
{
for (int i = 0; i < n; i++) Console.Write(match.Contains(digit) || match == "" ? ' ' : charToPrint);
}
}
}
```
My idea was to split the task up into 5 horizontal lines, which in turn are split up in a left, right and middle part for each character.
[Answer]
I guess there are very shorter solutions, but since this is not code-golf I'm quite satisfied!
This PHP script will take two numbers `a`, `b` from STDIN and echo `b` in LED format, at `a` size.
```
fscanf(STDIN, "%d %d", $a, $b); //Didn't test this line, but it should be ok.
$space=str_repeat(" ", $a);
$top = $topLeft = $topRight = $mid = $botLeft = $botRight = $bot = array();
for ($i=0; $i<count($b); $i++) {
$top[$i] = $topLeft[$i] = $topRight[$i] = $mid[$i] = $botLeft[$i] = $botRight[$i] = $bot[$i] = true;
switch ($b[$i]) {
case 0:
$mid[$i] = false;
break;
case 1:
$top[$i] = $topLeft[$i] = $mid[$i] = $botLeft[$i] = $bot[$i] = false;
break;
case 2:
$topLeft[$i] = $botRight[$i] = false;
break;
case 3:
$topLeft[$i] = $botLeft[$i] = false;
break;
case 4:
$top[$i] = $botLeft[$i] = $bot[$i] = false;
break;
case 5:
$topRight[$i] = $botLeft[$i] = false;
break;
case 6:
$topRight[$i] = false;
break;
case 7:
$topLeft[$i] = $mid[$i] = $botLeft[$i] = $bot[$i] = false;
break;
case 9:
$botLeft[$i] = false;
break;
}
}
horizontal($top);
vertical($topLeft, $topRight);
horizontal($mid);
vertical($botLeft, $botRight);
horizontal($bot);
function horizontal($position) {
global $a, $b, $space;
for ($i=0;$i<count($b);$i++) {
if ($position[$i])
echo " ".str_repeat("-", $a)." ";
else
echo " ".$space." ";
}
echo "<br />";
}
function vertical($positionLeft, $positionRight) {
global $a, $b, $space;
for ($j=0;$j<$a;$j++) {
for ($i=0;$i<count($b);$i++) {
if ($positionLeft[$i]) {
echo "|".$space;
if ($positionRight[$i])
echo "|;";
else
echo " ";
}
else {
echo " ".$space;
if ($positionRight[$i])
echo "|";
else
echo " ";
}
}
echo "<br />";
}
}
```
**EDIT:** Looking at the previous output example, I wrongly supposed that space between digits should be as large as the `a` size. This has been fixed with the OP's declaration that no space is needed.
[Answer]
## C#, 435 359 473 bytes
**EDITS:**
* Removed redundant code. Reduced byte size of comparisons.
* Converted to a stand-alone application using standard in for input.
Here's the golfed code (with added line breaks and whitespace):
```
using C=System.Console;
class P{
static void Main(){
var a=C.ReadLine().Split(' ');
D(int.Parse(a[0]),a[1]);
}
static void D(int r,string n){
int i,j;
string s="",v="|",w=" ",x=new string('_',r),y=new string(' ',r),z="\n";
foreach(var c in n)s+=w+(F(0,c)?x:y)+w+w;
for(j=1;j<6;j+=3)
for(i=r;i-->0;){
s+=z;
foreach(var c in n)s+=(F(j,c)?v:w)+(i<1&&F(j+1,c)?x:y)+(F(j+2,c)?v:w)+w;
}
C.Write(s+z);
}
static bool F(int i,char c){
return(new[]{1005,881,892,927,325,365,1019}[i]&1<<(int)c-48)>0;
}
}
```
[Answer]
## C (~~561~~ 492 bytes)
Author is frmar. He sent me his answer last week (he has not yet created his account).
### 492 bytes but a bit more obfuscated:
```
#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
#define C(x) ((_[*n-'0'])>>s)&m&x
#define P putchar
unsigned _[]={476,144,372,436,184,428,492,148,508,188};
void p(int a,char*n,unsigned m,int s)
{for(;isdigit(*n);++n){P(C(1)?'|':' ');
for(int i=0;i<a;++i)P(C(4)?'_':' ');
P(C(2)?'|':' ');}
P('\n');}
void l(int a,char*b){p(a,b,7,0);int i=1;
for(;i<a;++i)p(a,b,3,3);p(a,b,7,3);i=1;
for(;i<a;++i)p(a,b,3,6);p(a,b,7,6);}
int main(int c,char**v){l(c>1?atoi(v[1]):1,c>2?v[2]:"0123456789");}
```
### Previous version using 561 bytes:
```
#include<stdio.h>
#include<ctype.h>
#define C(x) ((((*n-'0')[_])>>s)&m&x)
const unsigned _[]={476,144,372,436,184,428,492,148,508,188};
void p(int a,const char*n,unsigned m,int s)
{
for(;isdigit(*n);++n) {
putchar(C(1)?'|':' ');
const char c=C(4)?'_':' ';
for(int i=0;i<a;++i) putchar(c);
putchar(C(2)?'|':' ');
}
putchar('\n');
}
void l(int a,const char*b)
{
p(a,b,7,0);
for(int i=1;i<a;++i)p(a,b,3,3);p(a,b,7,3);
for(int i=1;i<a;++i)p(a,b,3,6);p(a,b,7,6);
}
#include<stdlib.h>
int main(int c,char**v){l(c>1?atoi(v[1]):1,c>2?v[2]:"0123456789");}
```
### Original version from frmar (623 bytes):
```
#include<stdio.h>
#include<ctype.h>
const unsigned int _[]={476,144,372,436,184,428,492,148,508,188};
void p(int a,const char*n,unsigned int m,int s)
{
for(;isdigit(*n);++n) {
#define C(x) ((((*n-'0')[_])>>s)&m&x)
putchar(C(1)?'|':' ');
const char c=C(4)?'_':' ';
for(int i=0;i<a;++i) putchar(c);
putchar(C(2)?'|':' ');
}
putchar('\n');
}
void print_as_led(int a,const char*b)
{
p(a,b,7,0);
for(int i=1;i<a;++i)p(a,b,3,3);p(a,b,7,3);
for(int i=1;i<a;++i)p(a,b,3,6);p(a,b,7,6);
}
#include<stdlib.h>
int main(int argc,char**argv){print_as_led(argc>1?atoi(argv[1]):1,argc>2?argv[2]:"0123456789");}
```
### Compilation:
```
$ gcc -std=c99 -Wall print_as_led.c
```
### Examples using default `0123456789` number but different sizes:
```
$ ./a.out
_ _ _ _ _ _ _ _
| | | _| _||_||_ |_ ||_||_|
|_| ||_ _| | _||_| ||_| |
$ ./a.out 2
__ __ __ __ __ __ __ __
| | | | || || | || || |
| | | __| __||__||__ |__ ||__||__|
| | || | | || | || | |
|__| ||__ __| | __||__| ||__| |
$ ./a.out 3
___ ___ ___ ___ ___ ___ ___ ___
| | | | || || | || || |
| | | | || || | || || |
| | | ___| ___||___||___ |___ ||___||___|
| | || | | || | || | |
| | || | | || | || | |
|___| ||___ ___| | ___||___| ||___| |
```
### Other examples:
```
$ ./a.out 1 42
_
|_| _|
||_
$ ./a.out 2 42
__
| | |
|__| __|
||
||__
$ ./a.out 3 42
___
| | |
| | |
|___| ___|
||
||
||___
```
### Larger sizes:
```
$ ./a.out 4 42
____
| | |
| | |
| | |
|____| ____|
||
||
||
||____
$ ./a.out 5 42
_____
| | |
| | |
| | |
| | |
|_____| _____|
||
||
||
||
||_____
```
[Answer]
# Perl + FIGlet + BRA\*: 54 characters
```
while(<>){($n,$x)=split;print(`figlet -f 7seg$n $x`);}
```
I figured this would be quite easy to do with [FIGlet](http://www.figlet.org/), but there didn't appear to be any suitable fonts for this purpose. So I made some :-)
* [7seg1.flf](http://pastebin.com/Tr0ScP4E)
* [7seg2.flf](http://pastebin.com/5KT5qiDF)
* [7seg3.flf](http://pastebin.com/AzLjxbyQ)
Here's how it looks on the terminal:
```
$ perl ./led.pl
1 234
_ _
_| _||_|
|_ _| |
2 345
__ __
|| ||
__||__||__
| | |
__| | __|
3 456
___ ___
| || |
| || |
|___||___ |___
| || |
| || |
| ___||___|
```
\*BRA: blatant rule abuse
[Answer]
# PERL, 261 244 187 166 chars
Little bit of bitwise encoding philosophy rulez :-)
```
($n,$a)=split/ /;sub c{$_=$a;y/0-9/Gl+%<UWm7=/;s/./(substr" _ _|_| |_ |",2*ord($&)>>$_[0]&$_[1],3)=~s|.\K.|$&x$n|er/ge;print y/_/ /r x($n-1).$_}c 0,2;c 4,14;c 1,14
```
Code with whitespace added:
```
($n,$a)=split/ /;
sub c{
$_=$a;
y/0-9/Gl+%<UWm7=/;
s/./(substr" _ _|_| |_ |",2*ord($&)>>$_[0]&$_[1],3)=~s|.\K.|$&x$n|er/ge;
print y/_/ /r x($n-1).$_
}
c 0,2;
c 4,14;
c 1,14
```
Perl has to be invoked with `-n`:
```
$ perl -n digitize.zoom.pl
1 12304597
_ _ _ _ _ _
| _| _| | | |_| |_ |_| |
| |_ _| |_| | _| | |
2 0784
__ __ __
| | | | | | |
| | | |__| |__|
| | | | | |
|__| | |__| |
3 789
___ ___ ___
| | | | |
| | | | |
| |___| |___|
| | | |
| | | |
| |___| |
```
Notes:
* Everything about how digits are displayed is encoded in the string `Gl+%<UWm7=` :-) One character corresponds to one digit, encoded are 3 positions of 3 consecutive characters within the `" _ _|_| |_ |"` string.
* Numbers are constructed in 3 lines, line by line. Each of the 3 lines corresponds to one call to sub-routine `c`, which also accomplishes vertical zooming for second and third line.
* Horizontal zooming is done at the end of sub-routine `c`.
---
My `sed` program cannot zoom, but it looks a lot nicer, doesn't it? :-)
```
s/./\0 /g
h
s/[14]/ /g
s/[2305-9]/ _ /g
p
g
s/[17]/ |/g
s/[23]/ _|/g
s/[489]/|_|/g
s/[56]/|_ /g
s/0/| |/g
p
g
s/[147]/ |/g
s/2/|_ /g
s/[359]/ _|/g
s/[680]/|_|/g
```
Pretty much the idea my PERL script uses, but in PERL it's a lot uglier. Note that for my sed program I prefered to use `9` which has the underscore in the last line, to be like reversed 6.
[Answer]
## C#, 386 382 364 chars / 374 bytes (UTF-8) and (lots? of) room for improvement...
```
using System.Linq;using C=System.Console;class P{static void Main(string[] args){var s=C.ReadLine();for(int l=0;l<5;l++){for(int j=0;j<s.Length;j++)C.Write(string.Join("",Enumerable.Range(0,3).Select(i=>{var x=l*3+i;return((x&1)>0?((((System.Text.Encoding.Unicode.GetBytes("⑷浝欮╻潿")[(byte)s[j]-48]>>x/2)&1)==1)?(x-1%3>0?"|":"-"):" "):" ");}))+" ");C.WriteLine();}}}
```
**EDIT**
Crap... I missed the "scale" part 
I'll give it another shot if I get around to it..
[Answer]
# J - 147 95 characters
Added required scaling:
```
1!:2&2,./(([1 s 0 s=:1 :(':';'y#"(2-m)~(m{$y)$1,x'))"2(3 :'(y{(5 3$&,0&,.)"1@#:l)}d')@"."0@":)/".]1!:1]1[l=:>:a.i.'v#\Z9jnQ~z'[d=:' ',:5 3$' - | |'
```
Annotated version:
```
NB. Digit array (2 x 5 x 3) first is blank, second is filled.
d=:' ',:5 3$' - | |'
NB. Bits to selector (taking into account that all "usefull" bits are separated with 0 bits, looking at the 5 x 3 grid)
bts =: 5 3 $&, (0&,.)
NB. list of character bits.
l=: 119 36 93 91 58 107 111 82 127 123
NB. golfing using ascii range
l=: >:a.i.'v#\Z9jnQ~z'
NB. scaling function
NB. scaling in 1 direction involves inserting copies of the middle segments:
NB. from y, copy the middle segments, 1 x 1 x 1 for rank 2 and 1 x 1 for rank 1
NB. Usage: scale (rank s) segment
s=: 1 : (':';'y#"(2-m)~(m{$y)$1,x')
NB. scale first along columns, then along rows, apply only to rank 2 (planes)
b=:([1 s 0 s)"2
NB. Get one number by using amend with a selection array (0 is blank, 1 is filled)
NB. get the y'th plane from the array of 10 x 5 x 3 selector bits, use those to index d with.
g=: 3 : '(y { (bts"1 #: l)) } d'
NB. from right to left: read stdin, convert number string to numbers,
NB. use the left for scaling, and split the right in digits,then apply g,
NB. then paste them together so the numbers appear next to each other.
NB. Put this result on stdout
1!:2&2,./(b g@"."0@":)/".]1!:1]
```
Example:
```
1 0123456789
- - - - - - - -
| || | || || | || || |
- - - - - - -
| || | | | || | || | |
- - - - - - -
2 123
-- --
| | |
| | |
-- --
| | |
| | |
-- --
```
[Answer]
# Ruby,126 ASCII characters
```
->n,x{(n*2).downto(0){|i|x.bytes{|c|z='u"ik:[]b}{'[c-48].ord+2>>i/n*3&7
print' |'[z/2%2],(z%2>i%n ??_:' ')*n,' |'[z/4]}
puts}}
```
Each digit is encoded as a bitmap in thirds thus, with each third represented by an octal digit.
```
|_| 8^2 (left and right never used! only the 1's bit used!)
|_| 8^1 (4*right+2*left+1*bottom)
|_| 8^0 (4*right+2*left+1*bottom)
```
As all digits have either the 64's bit or 32's bit set, the range is 044 octal to 177 octal. Unfortunately 177 is the nonprintable DEL character, so the magic string contains the numbers 2 below the required bitmap code, and we have to add 2 back on in the function.
**Ungolfed in test program**
```
f=->n,x{
(n*2).downto(0){|i| #1 top line, n middle lines, n bottom lines
x.bytes{|c| #iterate through bytes
z='u"ik:[]b}{'[c-48].ord+2>>i/n*3&7 #find octal code for current 1/3 digit
print' |'[z/2%2],(z%2>i%n ??_:' ')*n,' |'[z/4]#print left,right and bottom
} #z%2>i%n only true on bottom row of 3rd where i%n=0 (print _'s) and octal code has 1's bit set
puts #print a newline to finish line
}
}
n=gets.to_i #size
x=gets.chop #number taken in string form
f[n,x]
```
**Output**
```
C:\Users\steve>ruby 7seg.txt
4
0123456789
____ ____ ____ ____ ____ ____ ____ ____
| | | | || || | || || |
| | | | || || | || || |
| | | | || || | || || |
| | | ____| ____||____||____ |____ ||____||____|
| | || | | || | || | |
| | || | | || | || | |
| | || | | || | || | |
|____| ||____ ____| | ____||____| ||____| ____|
```
[Answer]
## Perl 6, ~~284~~ ~~241~~ 237
```
my (\a,\n)=split " ",slurp.trim;my @p=n.comb;sub g(\b,\c){for @p {my $h=:36(b);$h+>=3*$_;for ^3 {my \e=$_==1;print " |_".substr($h%2&&(c+!e)&&1+e,1)x a**e;$h+>=1}};say ""};for <52N98I 0 HMTVAD 1 AZRXEV 1> ->\s,\q{g(s,0)for 2..a*q;g(s,1)}
```
Previous solutions:
```
my (\a,\n)=slurp.trim.split: " ";my @p=n.comb;sub g(\b,\c){for @p {my $h=b;$h+>=3*$_;for ^3 {my \e=$_==1;print " |_".substr($h%2&&(c+!e)&&1+e,1)x a**e;$h+>=1}};say ""};for 306775170,0,1066270117,1,664751335,1 ->\s,\q{g(s,0)for 2..a*q;g(s,1)}
my (\a,\n)=slurp.trim.split: " ";my @p=n.comb;my &f={print $^b.substr(3*$_,1)~($^c??$b.substr(3*$_+1,1)!!" ")x a~$b.substr(3*$_+2,1)for @p;say ""};for (" _ _ _ "~" _ "x 5,0,"| | | _| _||_||_ |_ ||_||_|",1,"|_| ||_ _| | _||_| ||_| |",1) ->\s,\q{f(s,0)for 2..a*q;f(s,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/16209/edit).
Closed 1 year ago.
[Improve this question](/posts/16209/edit)
I'm a bit of a romantic, I love taking my wife out to see the sunrises and sunsets in the place we are located. For the sake of this exercise let's say I don't have code that can tell me the time of either sunset or sunrise for whatever date, latitude and longitude I would happen to be in.
Your task, coders, is to generate the smallest code possible that takes a decimal latitude and longitude (taken in degrees N and W, so degrees S and E will be taken as negatives) and a date in the format YYYY-MM-DD (from Jan 1, 2000 onwards) and it will spit out two times in 24hr format for the sunrise and sunset.
e.g. For today in Sydney, Australia
```
riseset -33.87 -151.2 2013-12-27
05:45 20:09
```
Bonuses:
-100 if you can factor in elevation
-100 if you can factor daylight savings
The code MUST spit out times in the relevant time zone specified in the input based off the latitude and longitude OR in the client machine's own time zone.
[Answer]
I've spent quite some time writing this:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from math import *
class RiseSet(object):
__ZENITH = {'official': 90.833,
'civil': '96',
'nautical': '102',
'astronomical': '108'}
def __init__(self, day, month, year, latitude, longitude, daylight=False,
elevation=840, zenith='official'):
''' elevation is set to 840 (m) because that is the mean height of land above the sea level '''
if abs(latitude) > 63.572375290155:
raise ValueError('Invalid latitude: {0}.'.format(latitude))
if zenith not in self.__ZENITH:
raise ValueError('Invalid zenith value, must be one of {0}.'.format
(self.__ZENITH.keys()))
self.day = day
self.month = month
self.year = year
self.latitude = latitude
self.longitude = longitude
self.daylight = daylight
self.elevation = elevation
self.zenith = zenith
def getZenith(self):
return cos(radians(self.__ZENITH[self.zenith]))
def dayOfTheYear(self):
n0 = floor(275*self.month/9)
n1 = floor((self.month + 9) / 12)
n2 = (1 + floor((self.year - 4*floor(self.year/4) + 2) / 3))
return n0 - (n1*n2) + self.day - 30
def approxTime(self):
sunrise = self.dayOfTheYear() + ((6 - (self.longitude/15.0)) / 24)
sunset = self.dayOfTheYear() + ((18 - (self.longitude/15.0)) / 24)
return (sunrise, sunset)
def sunMeanAnomaly(self):
sunrise = (0.9856 * self.approxTime()[0]) - 3.289
sunset = (0.9856 * self.approxTime()[1]) - 3.289
return (sunrise, sunset)
def sunTrueLongitude(self):
sma = self.sunMeanAnomaly()
sunrise = sma[0] + (1.916*sin(radians(sma[0]))) + \
(0.020*sin(radians(2*sma[0]))) + 282.634
if sunrise < 0:
sunrise += 360
if sunrise > 360:
sunrise -= 360
sunset = sma[1] + (1.916*sin(radians(sma[1]))) + \
(0.020*sin(radians(2*sma[1]))) + 282.634
if sunset <= 0:
sunset += 360
if sunset > 360:
sunset -= 360
return (sunrise, sunset)
def sunRightAscension(self):
stl = self.sunTrueLongitude()
sunrise = atan(radians(0.91764*tan(radians(stl[0]))))
if sunrise <= 0:
sunrise += 360
if sunrise > 360:
sunrise -= 360
sunset = atan(radians(0.91764*tan(radians(stl[1]))))
if sunset <= 0:
sunset += 360
if sunset > 360:
sunset -= 360
sunrise_stl_q = (floor(stl[0]/90)) * 90
sunrise_ra_q = (floor(sunrise/90)) * 90
sunrise = sunrise + (sunrise_stl_q - sunrise_ra_q)
sunrise = sunrise/15.0
sunset_stl_q = (floor(stl[1]/90)) * 90
sunset_ra_q = (floor(sunset/90)) * 90
sunset = sunrise + (sunset_stl_q - sunset_ra_q)
sunset /= 15.0
return (sunrise, sunset)
def sunDeclination(self):
sunrise_sin_dec = 0.39782 * sin(radians(self.sunTrueLongitude()[0]))
sunrise_cos_dec = cos(radians(asin(radians(sunrise_sin_dec))))
sunset_sin_dec = 0.39782 * sin(radians(self.sunTrueLongitude()[1]))
sunset_cos_dec = cos(radians(asin(radians(sunrise_sin_dec))))
return (sunrise_sin_dec, sunrise_cos_dec,
sunset_sin_dec, sunset_cos_dec)
def sunHourAngle(self):
sd = self.sunDeclination()
sunrise_cos_h = (cos(radians(self.getZenith())) - (sd[0]* \
sin(radians(self.latitude))) / (sd[1]* \
cos(radians(self.latitude))))
if sunrise_cos_h > 1:
raise Exception('The sun never rises on this location.')
sunset_cos_h = (cos(radians(self.getZenith())) - (sd[2]* \
sin(radians(self.latitude))) / (sd[3]* \
cos(radians(self.latitude))))
if sunset_cos_h < -1:
raise Exception('The sun never sets on this location.')
sunrise = 360 - acos(radians(sunrise_cos_h))
sunrise /= 15.0
sunset = acos(radians(sunrise_cos_h))
sunset /= 15.0
return (sunrise, sunset)
def localMeanTime(self):
sunrise = self.sunHourAngle()[0] + self.sunRightAscension()[0] - \
(0.06571*self.approxTime()[0]) - 6.622
sunset = self.sunHourAngle()[1] + self.sunRightAscension()[1] - \
(0.06571*self.approxTime()[1]) - 6.622
return (sunrise, sunset)
def convertToUTC(self):
sunrise = self.localMeanTime()[0] - (self.longitude/15.0)
if sunrise <= 0:
sunrise += 24
if sunrise > 24:
sunrise -= 24
sunset = self.localMeanTime()[1] - (self.longitude/15.0)
if sunset <= 0:
sunset += 24
if sunset > 24:
sunset -= 24
return (sunrise, sunset)
def __str__(self):
return None
```
Now it's not yet functional (I screwed up some calculations) - I'll come back to it later (if I'll still have the courage) to [complete it / comment it](http://williams.best.vwh.net/sunrise_sunset_algorithm.htm).
Also, some interesting resources that I found while researching the subject:
* [How to compute planetary positions](http://stjarnhimlen.se/comp/ppcomp.html)
* [How to adjust sunrise and sunset times according to altitude?](https://photo.stackexchange.com/questions/30259/how-to-adjust-sunrise-and-sunset-times-according-to-altitude)
* [How To Convert a Decimal to Sexagesimal](http://geography.about.com/library/howto/htdegrees.htm)
* [When is the right ascension of the mean sun 0?](https://physics.stackexchange.com/questions/46700/when-is-the-right-ascension-of-the-mean-sun-0)
* [How do sunrise and sunset times change with altitude?](http://curious.astro.cornell.edu/question.php?number=388)
* [What is the maximum length of latitude and longitude?](https://stackoverflow.com/questions/15965166/what-is-the-maximum-length-of-latitude-and-longitude)
* [Computation of Daylengths, Sunrise/Sunset Times, Twilight and Local
Noon](http://www.sci.fi/~benefon/sol.html)
* [Position of the Sun](http://www.stargazing.net/kepler/sun.html)
] |
[Question]
[
**This question already has answers here**:
[Golfing the Core [closed]](/questions/38691/golfing-the-core)
(9 answers)
Closed 9 years ago.
You have to create a function `range`, such that it takes two (integer) arguments `a` and `b` (`a < b`) and returns all the numbers in between them. So:
```
range(5, 10) // should output 6, 7, 8, 9
range(-5, 2) // should output -4, -3, -2, -1, 0, 1
range(5, 0) // can throw an error/empty/null/undefined/whatever (a is not < b)
// bonus points for non integer handling
range(0.5, 4.5) // 1.5, 2.5, 3.5
range(0.5, 4) // range doesn't make sense, error/null/empty
range(5, 5) // etc. should return empty/null/undefined/whatever
```
Your code must **not use any numbers at all**, but you can use arithmetic operators. If your language has a `range` function in-built, you cannot use that as well.
Shortest code wins.
[Answer]
# Javascript (49)(45)
As feersum said, I do not know why anyone would have to use numbers here.
```
f=(a,b)=>{for(c=[];a<b;c.push(a++));return c}
```
Old:
```
f=(a,b)=>{c=[];for(;a<b;a++){c.push(a);}return c}
```
I am sure it can be golfed down further=)
] |
[Question]
[
You are given a list of numbers `L = [17, 5, 9, 17, 59, 14]`, a bag of operators `O = {+:7, -:3, *:5, /:1}` and a number `N = 569`.
## Task
Output an equation that uses all numbers in `L` on the left-hand side and only the number `N` on the right-hand side. If this is not possible, output False. Example solution:
```
59*(17-5)-9*17+14 = 569
```
## Limitations and Clarification
* You may not concatenate numbers (`[13,37]` may not be used as `1337`)
* Only natural numbers and zero will appear in `L`.
* The order in `L` doesn't matter.
* You must use all numbers in `L`.
* Only the operators `+`,`-`,`*`,`/` will appear in `O`.
* `O` can have more operators than you need, but at least `|L|-1` operators
* You may use each operator any number of times up to the value in `O`.
* All four operations in `O` are the standard mathematical operations; in particular, `/` is normal division with exact fractions.
## Points
* The less points, the better
* Every character of your code gives you one point
You have to provide an un-golfed version that is easy to read.
## Background
A [similar question](https://stackoverflow.com/q/15084049/562769) was asked on Stack Overflow. I thought it might be an interesting code-golf challenge.
## Computational Complexity
As Peter Taylor said in the comments, you can solve [subset sum](//en.wikipedia.org/wiki/Subset_sum_problem) with this:
1. You have an instance of subset sum (hence a set S of integers and a number x)
2. L := S + [0, ..., 0] (|S| times a zero), N := x, O := {+:|S|-1, \*: |S| - 1, /:0, -: 0}
3. Now solve this instance of my problem
4. The solution for subset sum is the numbers of S that don't get multiplied with zero.
If you find an Algorithm that is better than O(2^n), you prove that P=NP. As [P vs NP](//en.wikipedia.org/wiki/P_vs._NP) is a [Millennium Prize Problem](//en.wikipedia.org/wiki/Millennium_Prize_Problems) and hence worth 1,000,000 US-Dollar, it is very unlikely that somebody finds a solution for this. So I removed this part of the ranking.
## Test cases
The following are not the only valid answers, other solutions exist, and are permitted:
* (`[17,5,9,17,59,14]`, `{+:7, -:3, *:5, /:1}`, `569`)
**=>** `59 * (17-5)- 9 * 17 + 14 = 569`
* (`[2,2]`, `{'+':3, '-':3, '*':3, '/':3}`, `1`)
**=>** `2/2 = 1`
* (`[2,3,5,7,10,0,0,0,0,0,0,0]`, `{'+':20, '-':20, '*':20, '/':20}`, `16`)
**=>** `5+10-2*3+7+0+0+0+0+0+0+0 = 16`
* (`[2,3,5,7,10,0,0,0,0,0,0,0]`, `{'+':20, '-':20, '*':20, '/':20}`, `15`)
**=>** `5+10+0*(2+3+7)+0+0+0+0+0+0 = 15`
[Answer]
# Python 2.7 / 478 chars
```
L=[17,5,9,17,59,14]
O={'+':7,'-':3,'*':5,'/':1}
N=569
P=eval("{'+l+y,'-l-y,'*l*y,'/l/y}".replace('l',"':lambda x,y:x"))
def S(R,T):
if len(T)>1:
c,d=y=T.pop();a,b=x=T.pop()
for o in O:
if O[o]>0 and(o!='/'or y[0]):
T+=[(P[o](a, c),'('+b+o+d+')')];O[o]-=1
if S(R,T):return 1
O[o]+=1;T.pop()
T+=[x,y]
elif not R:
v,r=T[0]
if v==N:print r
return v==N
for x in R[:]:
R.remove(x);T+=[x]
if S(R,T):return 1
T.pop();R+=[x]
S([(x,`x`)for x in L],[])
```
The main idea is to use postfix form of an expression to search. For example, `2*(3+4)` in postfix form will be `234+*`. So the problem become finding a partly permutation of `L`+`O` that evalates to `N`.
The following version is the ungolfed version. The stack `stk` looks like `[(5, '5'), (2, '5-3', (10, ((4+2)+(2*(4/2))))]`.
```
L = [17, 5, 9, 17, 59, 14]
O = {'+':7, '-':3, '*':5, '/':1}
N = 569
P = {'+':lambda x,y:x+y,
'-':lambda x,y:x-y,
'*':lambda x,y:x*y,
'/':lambda x,y:x/y}
def postfix_search(rest, stk):
if len(stk) >= 2:
y = (v2, r2) = stk.pop()
x = (v1, r1) = stk.pop()
for opr in O:
if O[opr] > 0 and not (opr == '/' and v2 == 0):
stk += [(P[opr](v1, v2), '('+r1+opr+r2+')')]
O[opr] -= 1
if postfix_search(rest, stk): return 1
O[opr] += 1
stk.pop()
stk += [x, y]
elif not rest:
v, r = stk[0]
if v == N: print(r)
return v == N
for x in list(rest):
rest.remove(x)
stk += [x]
if postfix_search(rest, stk):
return True
stk.pop()
rest += [x]
postfix_search(list(zip(L, map(str, L))), [])
```
] |
[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 9 years ago.
[Improve this question](/posts/41829/edit)
ESL gaming, where you can challenge players to play games. I've provided some steps you can take manually to challenge a player. *Note that you have to signup for an account and have to be logged in to perform these steps. (Important: you have to sign-up for the ladder before you can challenge on that ladder too. Finally some ladders requires game guid to be added, so If you don't want to get involved with that, I suggest you signup for [this ladder](http://www.esl.eu/eu/pokerth/1on1/fixed_ladder/signup/), and wait for admin verification, which should happen in a few hours, and you are good to go.)*
---
### The challenge
**[Prerequisite]**: Figure out the technology powering the website, specifically sending the form. (The title is a hint.)
* Automate whole process. Fewest bytes to achieve a challenge on a ladder wins.
* **[-210 bytes bonus]** Make all the optional choices configurable, including:
+ [-40 bytes] The opponent to pick.
+ [-40 bytes] The ladder to challenge on.
+ [-30 bytes] The fields of the form.
+ **[-100 bytes extra bonus]** If you have chosen the path to take the bonus, make a nice gui to get this extra bonus.
---
### Steps
1. Go to the ladder webpage: <http://www.esl.eu/eu/cod4/promod/sd/1on1/ladder/>.
2. See the list of opponents, click on one (any, eg: [Hellraizer](http://www.esl.eu/eu/cod4/promod/sd/1on1/ladder/player/4044209/)).
3. On the player page: <http://www.esl.eu/eu/cod4/promod/sd/1on1/ladder/player/4044209/>
Scroll down to see Leagues&Tournaments where you can challenge player on a ladder.
4. Click [challenge!](http://www.esl.eu/eu/cod4/promod/dm/ladder/matchsetup/challenge/4790397/) on a Ladder. (SD or DM pick any).
It will show a form, you don't have to fill anything, just click SEND.
]
|
[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/38227/edit).
Closed 9 years ago.
[Improve this question](/posts/38227/edit)
A flowchart algorithm is a type of pseudocode designed for human readability and makes it easy to see the program flow.
For this program, you need to output your own program as a flowchart. You may not read your own source code and the output must be a PNG of any size.
The flowchat must be a step by step representation, therefore the number of blocks in your chart should roughly the same number of operations in your program.
Please include your code's output in your answer.
The shortest code wins.
## Specs
These are guidelines, if your language is not good enough to make the necessary calculations easily, you may approximate the shape as good as you can.
### Conditional
The largest angles in this diamond shape should be `126.86°` and the smallest angles should be `53.18°`. The colour of it should be HTML colour `#E5E4E2`. All of the sides should be the same length.
### Data Input/Output
The largest angles in this parallelogram should be `116.57°` and the smallest angles should be `63.43°`. The colour of it should be HTML colour `#667C26`. The long side to short side ratio should be 3:2.
### Process
This should be a rectangle with the colour being HTML colour `#FBF6D9`. The dimensions should be in the height-length ratio 2:3.
### Terminator
This should be an ovaloid with the colour being HTML colour `#B38481`. The dimensions should be in the height-length ratio 2:3.
### Arrowhead
This should be an isoceles triangle with the smallest angle being `40°` and the two bigger angles being `70°`. The entire arrow must be of HTML colour `#000000`.
<http://www.utexas.edu/courses/streeter/s15-5037.04/Overheads/Symbols.jpg>
]
|
[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/32814/edit).
Closed 9 years ago.
[Improve this question](/posts/32814/edit)
An airlines company has several planes of the same type.Each plane has a seating capacity of **24 X 3** rows and **8** seats in each row split has shown.
```
1 [a] [b] [c] [d] [e] [f] [g] [h]
2 [a] [b] [c] [d] [e] [f] [g] [h]
3 [a] [b] [c] [d] [e] [f] [g] [h]
```
>
> If 4 people book-allocate 4 seats in middle row.Else 2 on the right
> and 2 on the left.
>
>
> if 3 people book- id middle section is
> empty,allocate there continuously.Else go to next row middle section.
>
>
> if 2 people book-allocate the edge seats.
>
>
> if 1 person has booked -then allocate whatever free seat available.
>
>
>
eg-
**input** 4
**output**-1c 1d 1e 1f
**input**-3
**output**- 2c 2d 2e
**input**-2
**output**-1a 1b.
]
|
[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/25746/edit).
Closed 9 years ago.
[Improve this question](/posts/25746/edit)
Your challenge is to write a program which creates ASCII art from an input string, like [FIGlet](//en.wikipedia.org/wiki/FIGlet) or the Unix [banner](//en.wikipedia.org/wiki/Banner_%28Unix%29) utility.
Specifically, your program should take as input a string consisting of printable ASCII characters, and output an ASCII art representation of those characters in the order they appear in the input.
You're free to choose the details of what the output will look like, except that:
1. The output must be readable.
2. Simply representing each input character by itself in the output, with or without surrounding "decorative" characters, is considered cheating.
Also, you may not use any programs (like FIGlet), libraries or built-in tools designed for generating ASCII art, nor may your program rely on any external resources such as web services.
This is code golf, so the shortest program wins.
]
|
[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/20112/edit).
Closed 10 years ago.
[Improve this question](/posts/20112/edit)
For this, imagine that the following words are really nasty cuss words:
```
Frag, Smeg, Felgercarb, Blatherskite, Dadgum, Fnord, Smurf, Schmit
```
Now, I need to filter out swear words on my website.
Normally the site will search for these words and *\**\* them out:
```
I hate this s****ing cussword filter! It won't let me f***ging swear!
```
But people will just do this
```
I hate this sm.urfing cussword filter! Good thing I can get around the fr.agging thing.
```
or
```
Holy schm1t, this web application is great!
```
Some more examples that I've seen are on this page:
[Inversoft Profanity Filter](http://www.inversoft.com/features/profanity-filter/ "Inversoft Profanity Filter")
And then there's this: [Sc\*\*\*horpe Problem](http://en.wikipedia.org/wiki/Sc%2a%2a%2ahorpe_problem "Sc***horpe Problem")
Challenge: Find the shortest solution, using regular expressions, that removes the most cuss words.
**Note: This is a very very relevant link: [PHP chat log](http://chat.stackoverflow.com/transcript/message/14381995#14381995 "Stackoverflow PHP Chat 2014/1/30")**
]
|
[Question]
[
**This question already has answers here**:
[Finding "sub-palindromes" 2: subsequences.](/questions/862/finding-sub-palindromes-2-subsequences)
(3 answers)
Closed 10 years ago.
**Problem:** Remove characters from strings to make the longest (character length) palindrome possible. The first line gives an integer value of the number of strings to test. Each subsequent line is a string to test.
**Example Input:**
```
3 // Number of lines to test
GGABZXVYCCDBA
ABGBAD
ABC
```
**Example Output:**
```
ABCCBA
ABGBA
B
```
Shortest code wins.
[Answer]
Here is my solution in Java (not exactly short hah)...
```
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class Palindrome {
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(new File("src/pal.dat"));
int q = sc.nextInt();
sc.nextLine();
for (int z = 0; z < q; z++) {
String line = sc.nextLine();
int max = 0;
String maxP = "";
for (int k = 0; k < line.length(); k++) {
String p = calc(line.substring(k));
if (p.length() > max) {
max = p.length();
maxP = p;
}
}
System.out.println("Max Palindrome: " + maxP);
}
}
public static String calc(String s) {
if (s.length() == 0)
return "";
if (s.length() == 1 || (s.length() == 2 && s.charAt(0) != s.charAt(1)))
return s.charAt(0) + "";
if (s.length() == 2)
return s;
char[] arr = s.toCharArray();
boolean match = false;
int i = 0;
for (i = arr.length - 1; i > 0; i--) {
if (arr[i] == arr[0]) {
match = true;
break;
}
}
int max = 0;
String maxPalin = "";
for (int k = 1; k < i; k++) {
String p = calc(s.substring(k, i));
if (p.length() > max) {
max = p.length();
maxPalin = p;
}
}
if (match)
return arr[0] + maxPalin + arr[0];
return maxPalin;
}
}
```
] |
[Question]
[
If you like, write a program which sorts cities according to the rules of city name game.
* Each name of the city should start from the last letter in the previous city name. E.g. `Lviv -> v -> Viden -> n -> Neapolis -> s -> Sidney -> y -> Yokogama -> a -> Amsterdam -> m -> Madrid -> d -> Denwer`
* In the sorted list first letter of the first city and last letter of the last shouldn't match anything doesn't have to be the same letter.
* You can assume city names have only letters.
* Program output should have same capitalization as input
Example:
```
% ./script Neapolis Yokogama Sidney Amsterdam Madrid Lviv Viden Denwer
["Lviv", "Viden", "Neapolis", "Sidney", "Yokogama", "Amsterdam", "Madrid", "Denwer"]
```
[Answer]
### Ruby, 58 55 44 characters
```
p$*.permutation.find{|i|i*?,!~/(.),(?!\1)/i}
```
Yet another ruby implementation. Uses also case insensitive regex (as [Ventero](https://codegolf.stackexchange.com/users/84/ventero)'s old [solution](https://codegolf.stackexchange.com/a/6657)) but the test is done differently.
Previous version:
```
p$*.permutation.find{|i|(i*?,).gsub(/(.),\1/i,"")!~/,/}
```
[Answer]
## Python (~~162~~ ~~141~~ 124)
Brute force for the win.
```
from itertools import*
print[j for j in permutations(raw_input().split())if all(x[-1]==y[0].lower()for x,y in zip(j,j[1:]))]
```
[Answer]
# Python, 113
Very similar to @beary605's answer, and even more brute-forced.
```
from random import*
l=raw_input().split()
while any(x[-1]!=y[0].lower()for x,y in zip(l,l[1:])):
shuffle(l)
print l
```
[Answer]
## Ruby 1.9, ~~63~~ 54 characters
New solution is based on [Howard](https://codegolf.stackexchange.com/users/1490/howard)'s [solution](https://codegolf.stackexchange.com/a/6658/84):
```
p$*.permutation.max_by{|i|(i*?,).scan(/(.),\1/i).size}
```
This uses the fact that there'll always be a valid solution.
Old solution, based on [w0lf](https://codegolf.stackexchange.com/users/3527/w0lf)'s [solution](https://codegolf.stackexchange.com/a/6645/84):
```
p$*.permutation.find{|i|i.inject{|a,e|a&&e[0]=~/#{a[-1]}/i&&e}}
```
[Answer]
## Ruby ~~74 72 104 103 71~~ 70
```
p$*.permutation.find{|i|i.inject{|a,e|a[-1].casecmp(e[0])==0?e:?,}>?,}
```
**Demo:** <http://ideone.com/MDK5c> (in the demo I've used `gets().split()` instead of `$*`; I don't know if Ideone can simulate command-line args).
[Answer]
# [Haskell](https://www.haskell.org/), ~~94~~ 74 bytes
```
g[a]=[[a]]
g c=[b:r|b<-c,r<-g[x|x<-c,x/=b],last b==[r!!0!!0..]!!32]
head.g
```
Recursively finds all solutions. -7 bytes if it's ok to output all solutions instead of the first. Thanks to @Lynn for getting rid of the pesky import, shaving 18 bytes off the score!
[Try it online!](https://tio.run/##FYyxCsIwFAD3fsVrcbRVdBMzCI7qIggSM7w2r2lompYktBX67UaF47jpGvQtGRNr9ooNoSxUojgKxn8SiYKK8fLglvKYV2t3zBWfl/nf84aVYm3QBygZ4y5Ntz@KQqTpfidiIB/Y1DvpIbsRDr3RHp592yvsEO5aWnrDqfOBnMQOriidlnAZ9QgPLcnCmexELkuSDrVlg9M2wApq@I/jp6oNKh/zahi@ "Haskell – Try It Online")
[Answer]
### GolfScript, 78 characters
```
" ":s/.{1${1$=!},{:h.,{1$-1={1$0=^31&!{[1$1$]s*[\](\h\-c}*;}+/}{;.p}if}:c~;}/;
```
A first version in GolfScript. It also does a brute force approach. You can see the script running on the example input [online](http://golfscript.apphb.com/?c=OyJOZWFwb2xpcyBZb2tvZ2FtYSBTaWRuZXkgQW1zdGVyZGFtIE1hZHJpZCBMdml2IFZpZGVuIERlbndlciIKCiIgIjpzLy57MSR7MSQ9IX0sezpoLix7MSQtMT17MSQwPV4zMSYhe1sxJDEkXXMqW1xdKFxoXC1jfSo7fSsvfXs7LnB9aWZ9OmN%2BO30vOwo%3D).
[Answer]
# [Husk](https://github.com/barbuz/Husk), 10 bytes
```
←fΛ~=o_←→P
```
[Try it online!](https://tio.run/##yygtzv7//1HbhLRzs@ts8@OBrEdtkwL@//8freSXmliQn5NZrKSj5FOWWQakXFLzylOLgIzgzJS81EogIywzJTUPSEfmZ@enJ@YmApm@iSlFmSlAhmNucUlqUUpirlIsAA "Husk – Try It Online")
### Explanation
```
←fΛ~=(_←)→P -- example input: ["Xbc","Abc","Cba"]
P -- all permutations: [["Xbc","Abc","Cba"],…,[Xbc","Cba","Abc"]]
f -- filter by the following (example with ["Xbc","Cba","Abc"])
Λ -- | all adjacent pairs ([("Xbc","Cba"),("Cba","Abc")])
~= -- | | are they equal when..
(_←) -- | | .. taking the first character lower-cased
→ -- | | .. taking the last character
-- | : ['c'=='c','a'=='a'] -> 4
-- : [["Xbc","Cba","Abc"]]
← -- take the first element: ["Xbc","Cba","Abc"]
```
### Alternatively, 10 bytes
We could also count the number of adjacent pairs which satisfy the predicate (`#`), sort on (`Ö`) that and take the last element (`→`) for the same number of bytes:
```
→Ö#~=o_←→P
```
[Try it online!](https://tio.run/##yygtzv7//1HbpMPTlOts8@MftU0AcgL@//8freSXmliQn5NZrKSj5FOWWQakXFLzylOLgIzgzJS81EogIywzJTUPSEfmZ@enJ@YmApm@iSlFmSlAhmNucUlqUUpirlIsAA "Husk – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 25 18 bytes (Improvements welcome!)
```
UżḢŒuE
ḲŒ!çƝẠ$ÐfḢK
```
[Try it online!](https://tio.run/##AVkApv9qZWxsef//VcW84biixZJ1RQrhuLLFkiHDp8ad4bqgJMOQZuG4okv///9OZWFwb2xpcyBZb2tvZ2FtYSBTaWRuZXkgQW1zdGVyZGFtIE1hZHJpZCBWaWRlbg "Jelly – Try It Online")
```
UżḢŒuE dyadic (2-arg) "check two adjacent city names" function:
Uż pair (żip) the letters of the reversed left argument with the right argument,
Ḣ get the Ḣead of that pairing to yield just the last letter of left and the first letter of right,
Œu capitalize both letters,
E and check that they're equal!
ḲŒ!çƝẠ$ÐfḢK i/o and check / fold function:
ḲŒ! split the input on spaces and get all permutations of it,
çƝẠ$ run the above function on every adjacent pair (çƝ), and return true if Ȧll pairs are true
Ðf filter the permutations to only get the correct ones,
ḢK take the first of those, and join by spaces!
```
Thanks to @Lynn for most of these improvements!
**25-byte solution:**
```
Uḣ1Œu=⁹ḣ1
çƝȦ
ḲŒ!©Ç€i1ị®K
```
[Try it online!](https://tio.run/##y0rNyan8/z/04Y7Fhkcnldo@atwJYnIdXn5s7ollXA93bDo6SfHQysPtj5rWZBo@3N19aJ33/////VITC/JzMosVIvOz89MTcxMVgjNT8lIrFRxzi0tSi1IScxV8E1OKMlMUfMoyyxTCMlNS8xRcUvPKU4sA "Jelly – Try It Online")
```
Uḣ1Œu=⁹ḣ1 dyadic (2-arg) "check two adjacent city names" function:
Uḣ1Œu reverse the left arg, get the ḣead, and capitalize it (AKA capitalize the last letter),
=⁹ḣ1 and check if it's equal to the head (first letter) of the right argument.
çƝȦ run the above function on every adjacent pair (çƝ), and return true if Ȧll pairs are true
ḲŒ!©Ç€i1ị®K main i/o function:
ḲŒ!© split the input on spaces and get all its permutations, ©opy that to the register
Ç€ run the above link on €ach permutation,
i1 find the index of the first "successful" permutation,
ị®K and ®ecall the permutation list to get the actual ordering at that ịndex, separating output by spaces
```
[Answer]
# Mathematica 236 chars
Define the list of cities:
```
d = {"Neapolis", "Yokogama", "Sidney", "Amsterdam", "Madrid", "Lviv", "Viden", "Denver"}
```
Find the path that includes all cities:
```
c = Characters; f = Flatten;
w = Outer[List, d, d]~f~1;
p = Graph[Cases[w, {x_, y_} /;x != y \[And] (ToUpperCase@c[x][[-1]]== c[y][[1]]) :> (x->y)]];
v = f[Cases[{#[[1]], #[[2]], GraphDistance[p, #[[1]], #[[2]]]} & /@ w, {_, _, Length[d] - 1}]];
FindShortestPath[p, v[[1]], v[[2]]]
```
Output:
```
{"Lviv", "Viden", "Neapolis", "Sidney", "Yokogama", "Amsterdam","Madrid", "Denver"}
```
The above approach assumes that the cities can be arranged as a path graph.
---
The graph p is shown below:
[Answer]
# C, 225
```
#define S t=v[c];v[c]=v[i];v[i]=t
#define L(x)for(i=x;i<n;i++)
char*t;f;n=0;main(int c,char**v){int i;if(!n)n=c,c=1;if(c==n-1){f=1;L(2){for(t=v[i-1];t[1];t++);if(v[i][0]+32-*t)f=n;}L(f)puts(v[i]);}else L(c){S;main(c+1,v);S;}}
```
Run with country names as the command line arguments
Note:
* brute force generation of permutations
* for checking it assumes that country names start with an upper case and end in lower case.
* assumes there is only one answer
* In C, assumes that the \*\*v array of main() is writable
[Answer]
## J, 69 65 60 59 54 characters
Somewhat off the pace.
```
{.l\:+/2=/\|:tolower;"2({.,{:)@>l=.(i.@!@#A.]);:1!:1[1
```
Example:
```
{.l\:+/2=/\|:tolower;"2({.,{:)@>l=.(i.@!@#A.]);:1!:1[1
Neapolis Yokogama Sydney Amsterdam Madrid Lviv Viden Denwer
+----+-----+--------+------+--------+---------+------+------+
|Lviv|Viden|Neapolis|Sydney|Yokogama|Amsterdam|Madrid|Denwer|
+----+-----+--------+------+--------+---------+------+------+
```
[Answer]
**C#, 398**
And here is C# with Linq 5 cents
```
IEnumerable<string>CityNameGame(string[]input){var cities=new List<string>(input);string lastCity=null;while(cities.Any()){var city=lastCity??cities.First();lastCity=cities.First(name=>string.Equals(city.Substring(city.Length-1),name.Substring(0,1),StringComparison.CurrentCultureIgnoreCase));cities.RemoveAll(name=>name==city||name==lastCity);yield return string.Format("{0}→{1}",city,lastCity);}}
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~374 bytes~~ 302 bytes
```
using System;using System.Linq;class Program{static void Main(string[] s){Func<char, char>u=(c)=>char.ToUpperInvariant(c);var S="";int I=0,C=s.Count();for(;I<C;I++)S=Array.Find(s,x=>u(s[I][0])==u(x[^1]))==null?s[I]:S;for(I=0;I<C;I++){Console.Write(S+" ");S=C>I?Array.Find(s,x=>u(S[^1])==u(x[0])):"";}}}
```
[Try it online!](https://tio.run/##ZZBtS8MwFIX/yqWfGjbLXt1Llo5RGRSmCPEFKRVCGmewTWaS1o2x316zCSL45XIuh/vcw@H2imsj2ra2Um2BHqwTFf67RBupPjEvmbVwb/TWsOpoHXOSQ6NlAbdMqtA64y@yHCw6rmvFF/ydmS6cZ1yTkCMSn3X0oB93O2FS1TAjmXLewV4CJUGApXKQkl43ITZKdO1dhN@0CXG6SHDa6SBKVsawQ7SWqghtd0/iOrRZmme9HBFSh/vstZ8jL1VdlsuzM6cXgqf@Qo6JVlaXIno20omQdgIIEKYkidPlfzy9IH/g/gua@5yn06lt2zvBdrqUFl70h96yigGVhRIHWFW@NlOwyldTGN/QppENPMlCKLgR6kuYdjKF4QgGQ5jOoD@A0RiuJzDrwfj6Gw "C# (.NET Core) – Try It Online")
```
using System;
using System.Linq;
class Program
{
static void Main(string[] s)
{
Func<char, char> u = (c) => char.ToUpperInvariant(c);
var S = "";
int I = 0, C = s.Count();
for (; I < C; I++)
S = Array.Find(s, x => u(s[I][0]) == u(x[^1])) == null ? s[I] : S;
for (I = 0; I < C; I++)
{
Console.Write(S + " ");
S = C > I ? Array.Find(s, x => u(S[^1]) == u(x[0])) : "";
}
}
}
```
---
[Try it online!](https://tio.run/##bVHLbtswEDxXX7HQJSTsKM77oTJBoMKAAKcoyrRBEOTASqxCVCJdknZtGPp2lbQqR2qyF@1iRzvDmczsZ0rzZmGELICujeVVHPSnaCbk7zjISmYMfNGq0KwKNgG4MpZZkcFSiRzumJDIWO1@fHoGpguDt5gW6eun42HZyz@Qh4CQPeQQ7WuK3Dai81JYtAd7GMeDdaKkUSWPHrSw3KnkqAeod93BwU4WBQIbCD9zNlelMOEYwkf1SxWsYr6nIpd87bvbyj1d56zywx3Ltch9N1uKpf9@FzmXvvnE5R@uQ6jjHt0UUdyfO51fOcs7iXXwxsHpq32dd82SaaAkDGMhLaRkMk6IiRK1kNYdcoaiOP2YxOlohCm51Zqto6mQOTLjFbk2T@lzRBc/2qtoMj7E0b36Np9zjTAhq95uFc24LOzLfh/iMHJRljf@zhXdsjkFO8LNwH5ERyGEOKYkuU5v/pdCe1z0Pa6hnKFUfOXeXzcf6qBumi466HKDNjTYJQZtXOCzgm1Q0KbUnF/A8QkcHcPFJRwewckpnJ3D5QROz/4C "C# (.NET Core) – Try It Online")
```
using System;
using System.Linq;
var S = "";
int I = 0, C = s.Count();
for (; I < C; I++)
S = Array.Find(
s, x =>
s[I].Substring(0, 1).ToUpper() == x.Substring(x.Length - 1).ToUpper()
) == null ?
s[I] :
S;
for (I = 0; I < C; I++) {
Console.Write(S + " ");
S = C > I ? Array.Find(s, x => S.Substring(S.Length - 1).ToUpper() == x.Substring(0, 1).ToUpper()) : "";
}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-g`](https://codegolf.meta.stackexchange.com/a/14339/), 12 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
á kÈäÈÌkYÎÃd
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWc&code=4SBryOTIzGtZzsNk&input=WyJOZWFwb2xpcyIsIllva29nYW1hIiwiU2lkbmV5IiwiQW1zdGVyZGFtIiwiTWFkcmlkIiwiTHZpdiIsIlZpZGVuIiwiRGVud2VyIl0)
[Answer]
# K, 96
```
{m@&{&/(~).'+(,_1_1#'x),,-1_-1#'x}@'$m:{$[x=1;y;,/.z.s[x-1;y]{x,/:{x@&~x in y}[y;x]}\:y]}[#x;x]}
```
.
```
k){m@&{&/(~).'+(,_1_1#'x),,-1_-1#'x}@'$m:{$[x=1;y;,/.z.s[x-1;y]{x,/:{x@&~x in y}[y;x]}\:y]}[#x;x]}`Neapolis`Yokogama`Sidney`Amsterdam`Madrid`Lviv`Viden`Denver
Lviv Viden Neapolis Sidney Yokogama Amsterdam Madrid Denver
```
] |
[Question]
[
**This question already has answers here**:
[Build a solver for the cow and chicken problem](/questions/12360/build-a-solver-for-the-cow-and-chicken-problem)
(5 answers)
Closed 10 years ago.
An old Chinese poem goes:
>
> 一百饅頭一百僧，
>
> 大僧三個更無爭，
>
> 小僧三人分一個，
>
> 大小和尚得幾丁？
>
>
>
When translated into English, this math problem reads:
>
> 100 buns and 100 monks,
>
> Big monks eat 3 buns with no shortage,
>
> Little monks share one bun among three,
>
> Big and little monks, how many are there?
>
>
>
Once again, like in [the cow and chicken problem](https://codegolf.stackexchange.com/questions/12360/build-a-solver-for-the-cow-and-chicken-problem), there is no simple calculation you can perform. You need the power of systems of equations.
Your task is to build a program that takes the following inputs, all positive integers:
* b, the number of buns.
* m, the number of monks.
* bl, the number of buns a big monk can eat.
* ms, the number of small monks who share one bun.
and output `l` and `s`, the number of big monks and small monks respectively. ("L" stands for "large").
Again, this problem has various states of solvability, but this time around, only output something if there is a unique solution in the nonnegative integers.
The shortest code to do all of the above in any language wins.
---
The problem input of the poem is `100 100 3 3`, and the solution is `25 75`.
[Answer]
### R: 81 characters
```
i=scan();p=combn(0:i[2],2);cat(p[,p[1,]+p[2,]==i[2]&i[3]*p[1,]+p[2,]/i[4]==i[1]])
```
A brute force solver which takes all possible combinations of non-negative integers and subset the one corresponding to criteria.
[Answer]
## F#: 125 characters
```
printf"%O"(Console.ReadLine().Split()|>Seq.map Int32.Parse|>Seq.toArray|>fun[|b;m;x;y|]->((m-b*y)/(1-x*y),m-(m-b*y)/(1-x*y)))
```
This is my first attempt at code golf (here anyway), so I'm sure this could be improved. It simply reads the input, parses it, then does a little number crunching to get the correct results.
The result will be formatted like this:
```
(25, 75)
```
] |
[Question]
[
Using your language of choice, golf a [quine](http://en.wikipedia.org/wiki/Quine_%28computing%29).
>
> A **quine** is a non-empty computer program which takes no input and produces a copy of its own source code as its only output.
>
>
>
No cheating -- that means that you can't just read the source file and print it. Also, in many languages, an empty file is also a quine: that isn't considered a legit quine either.
No error quines -- there is already a [separate challenge](https://codegolf.stackexchange.com/questions/36260/make-an-error-quine) for error quines.
Points for:
* Smallest code (in bytes)
* Most obfuscated/obscure solution
* Using esoteric/obscure languages
* Successfully using languages that are difficult to golf in
The following Stack Snippet can be used to get a quick view of the current score in each language, and thus to know which languages have existing answers and what sort of target you have to beat:
```
var QUESTION_ID=69;
var OVERRIDE_USER=98;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}
function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}
function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=!1;comment_page=1;getComments()}})}
function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}
getAnswers();var SCORE_REG=(function(){var headerTag=String.raw `h\d`
var score=String.raw `\-?\d+\.?\d*`
var normalText=String.raw `[^\n<>]*`
var strikethrough=String.raw `<s>${normalText}</s>|<strike>${normalText}</strike>|<del>${normalText}</del>`
var noDigitText=String.raw `[^\n\d<>]*`
var htmlTag=String.raw `<[^\n<>]+>`
return new RegExp(String.raw `<${headerTag}>`+String.raw `\s*([^\n,]*[^\s,]),.*?`+String.raw `(${score})`+String.raw `(?=`+String.raw `${noDigitText}`+String.raw `(?:(?:${strikethrough}|${htmlTag})${noDigitText})*`+String.raw `</${headerTag}>`+String.raw `)`)})();var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}
function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))
body='<h1>'+c.body.replace(OVERRIDE_REG,'')+'</h1>'});var match=body.match(SCORE_REG);if(match)
valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,})});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)
lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery('<i>'+a.language+'</i>').text().toLowerCase();languages[lang]=languages[lang]||{lang:a.language,user:a.user,size:a.size,link:a.link,uniq:lang}});var langs=[];for(var lang in languages)
if(languages.hasOwnProperty(lang))
langs.push(languages[lang]);langs.sort(function(a,b){if(a.uniq>b.uniq)return 1;if(a.uniq<b.uniq)return-1;return 0});for(var i=0;i<langs.length;++i)
{var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
```
```
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table>
```
[Answer]
## [Hexagony](https://github.com/mbuettner/hexagony), side-length ~~17~~ 16, ~~816~~ 705 bytes
```
180963109168843880558244491673953327577233938129339173058720504081484022549811402058271303887670710274969455065557883702369807148960608553223879503892017157337685576056512546932243594316638247597075423507937943819812664454190530214807032600083287129465751195839469777849740055584043374711363571711078781297231590606019313065042667406784753422844".".>.@.#.#.#.#.#.#.#.>.(...........................<.".......".".>./.4.Q.;.+.<.#.>...........................<.".....".".>.#.#.>.N.2.'.\.>.............=.=......._.<.".....".".>.>.;.'.=.:.\.>.......................<."...".".>.\.'.%.'.<.#.>..............._.....<."...".".>.#.#.>.<.#.>...............=.=.<.".".".>.#.\.'.R./.>.................<.".!.........../.>.
```
[Try it online!](http://hexagony.tryitonline.net/#code=MTgwOTYzMTA5MTY4ODQzODgwNTU4MjQ0NDkxNjczOTUzMzI3NTc3MjMzOTM4MTI5MzM5MTczMDU4NzIwNTA0MDgxNDg0MDIyNTQ5ODExNDAyMDU4MjcxMzAzODg3NjcwNzEwMjc0OTY5NDU1MDY1NTU3ODgzNzAyMzY5ODA3MTQ4OTYwNjA4NTUzMjIzODc5NTAzODkyMDE3MTU3MzM3Njg1NTc2MDU2NTEyNTQ2OTMyMjQzNTk0MzE2NjM4MjQ3NTk3MDc1NDIzNTA3OTM3OTQzODE5ODEyNjY0NDU0MTkwNTMwMjE0ODA3MDMyNjAwMDgzMjg3MTI5NDY1NzUxMTk1ODM5NDY5Nzc3ODQ5NzQwMDU1NTg0MDQzMzc0NzExMzYzNTcxNzExMDc4NzgxMjk3MjMxNTkwNjA2MDE5MzEzMDY1MDQyNjY3NDA2Nzg0NzUzNDIyODQ0Ii4iLj4uQC4jLiMuIy4jLiMuIy4jLj4uKC4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLjwuIi4uLi4uLi4iLiIuPi4vLjQuUS47LisuPC4jLj4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi48LiIuLi4uLiIuIi4-LiMuIy4-Lk4uMi4nLlwuPi4uLi4uLi4uLi4uLi49Lj0uLi4uLi4uXy48LiIuLi4uLiIuIi4-Lj4uOy4nLj0uOi5cLj4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLjwuIi4uLiIuIi4-LlwuJy4lLicuPC4jLj4uLi4uLi4uLi4uLi4uLi5fLi4uLi48LiIuLi4iLiIuPi4jLiMuPi48LiMuPi4uLi4uLi4uLi4uLi4uLj0uPS48LiIuIi4iLj4uIy5cLicuUi4vLj4uLi4uLi4uLi4uLi4uLi4uLjwuIi4hLi4uLi4uLi4uLi4vLj4u&input=)
This is what it looks like unfolded:
```
1 8 0 9 6 3 1 0 9 1 6 8 8 4 3 8
8 0 5 5 8 2 4 4 4 9 1 6 7 3 9 5 3
3 2 7 5 7 7 2 3 3 9 3 8 1 2 9 3 3 9
1 7 3 0 5 8 7 2 0 5 0 4 0 8 1 4 8 4 0
2 2 5 4 9 8 1 1 4 0 2 0 5 8 2 7 1 3 0 3
8 8 7 6 7 0 7 1 0 2 7 4 9 6 9 4 5 5 0 6 5
5 5 7 8 8 3 7 0 2 3 6 9 8 0 7 1 4 8 9 6 0 6
0 8 5 5 3 2 2 3 8 7 9 5 0 3 8 9 2 0 1 7 1 5 7
3 3 7 6 8 5 5 7 6 0 5 6 5 1 2 5 4 6 9 3 2 2 4 3
5 9 4 3 1 6 6 3 8 2 4 7 5 9 7 0 7 5 4 2 3 5 0 7 9
3 7 9 4 3 8 1 9 8 1 2 6 6 4 4 5 4 1 9 0 5 3 0 2 1 4
8 0 7 0 3 2 6 0 0 0 8 3 2 8 7 1 2 9 4 6 5 7 5 1 1 9 5
8 3 9 4 6 9 7 7 7 8 4 9 7 4 0 0 5 5 5 8 4 0 4 3 3 7 4 7
1 1 3 6 3 5 7 1 7 1 1 0 7 8 7 8 1 2 9 7 2 3 1 5 9 0 6 0 6
0 1 9 3 1 3 0 6 5 0 4 2 6 6 7 4 0 6 7 8 4 7 5 3 4 2 2 8 4 4
" . " . > . @ . # . # . # . # . # . # . # . > . ( . . . . . .
. . . . . . . . . . . . . . . . . . . . . < . " . . . . . .
. " . " . > . / . 4 . Q . ; . + . < . # . > . . . . . . .
. . . . . . . . . . . . . . . . . . . . < . " . . . . .
" . " . > . # . # . > . N . 2 . ' . \ . > . . . . . .
. . . . . . . = . = . . . . . . . _ . < . " . . . .
. " . " . > . > . ; . ' . = . : . \ . > . . . . .
. . . . . . . . . . . . . . . . . . < . " . . .
" . " . > . \ . ' . % . ' . < . # . > . . . .
. . . . . . . . . . . _ . . . . . < . " . .
. " . " . > . # . # . > . < . # . > . . .
. . . . . . . . . . . . = . = . < . " .
" . " . > . # . \ . ' . R . / . > . .
. . . . . . . . . . . . . . . < . "
. ! . . . . . . . . . . . / . > .
. . . . . . . . . . . . . . . .
```
Ah well, this was quite the emotional rollercoaster... I stopped counting the number of times I switched between "haha, this is madness" and "wait, if I do *this* it should actually be fairly doable". The constraints imposed on the code by Hexagony's layout rules were... severe.
It might be possible to reduce the side-length by 1 or 2 without changing the general approach, but it's going to be tough (only the cells with `#` are currently unused *and* available for the decoder). At the moment I also have absolutely no ideas left for how a more efficient approach, but I'm sure one exists. I'll give this some thought over the next few days and maybe try to golf off one side-length, before I add an explanation and everything.
Well at least, I've proven it's possible...
Some CJam scripts for my own future reference:
* [Encoder](http://cjam.aditsu.net/#code=qS-N-Y%2514f-W%2582b)
* [Literal-shortcut finder](http://cjam.aditsu.net/#code='%5B%2C_el%5EA%2Cm*%7B_N%2B%5CAb256%2546%3D*%7D%2F)
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), side length 11, 314 bytes
```
164248894991581511673077637999211259627125600306858995725520485910920851569759793601722945695269172442124287874075294735023125483.....!/:;.........)%'=a':\....................\...................\..................\.................\................\...............\..............\..$@.........\$><>'?2='%.<\:;_;4Q
```
[Try it online!](https://tio.run/##jYy7CsJQEAW/RUgINnF37z7z0l@wvyApRCtt9evjtRAbUadZZg7s@XibT9fLfVlQmdg9OALFURDVEphpsoggRJJQsnIUIIG6eIQYiRCwSyAEgQuKhklYJAU0ouAShDSKMBMSk5sbg0nZLAlQKj/ZU/tkten69sW6bsa56XL7gfxfy79L/u5Fq93bqmmYmi2NTd0OuesPPe@X5QE "Hexagony – Try It Online")
---
Note: Currently [the shortest program](https://codegolf.stackexchange.com/questions/69/golf-you-a-quine-for-great-good/193220#193220) is only **261** bytes long, using a similar technique.
Older version:
# [Hexagony](https://github.com/m-ender/hexagony), side length 11, 330 bytes
```
362003511553420961423766261426252539048636523959468260999944549820033581478284471415809677091006384959302453627348235790194699306179..../:{;+'=1P'%'a{:..\.....................\...................\..................\.................\................\...............\..............\.............\!$><........\..@>{?2'%<......:;;4Q/
```
[Try it online!](https://tio.run/##jY29CsJAEISfRVBSCHH/bzfR6CNof00K0UpbJQ8fL2ChIOpUO98yM@fjrT9dL/dxZCMAVkRVFoIwFOJkRtNhpKQcIG5sShwaYk4GUSSiEj6lWR0lOblIQkH1UpMSBAIYu5QUA4mWqcTixJoCsDRF4YYp6qJVM7TLaoP7alH1Q1PXuf6k/B/Lv0n@7t9tns279ctr1w1bqhZP1LStHFbj@AA "Hexagony – Try It Online")
Encoder: [Try it online!](https://tio.run/##jZHNTsMwEITvfoohApoQ6v4hIdKmIMGFG6hHysEkTmyRJpVj0Up9@LJxCuKEnMiyvfPtatarRPspq@p41JttYyyehBX8UQnDmKyzJpdIEqys0XWJ4RLPtZWlND9aa5GiwDkKXVlpENaN5bpdbUUmI1IZdkoayYgJAvRfinF3Dwd8kHTLRq6GxdUU8cRJmQJcnAG6wHiR5rrUFpeXcIfFh2ipKKySNUKXiy6EuNcjuk9JlxXFpDENOQu6pkTWuQwQx3jL1Hu3B9AtyDa@RKXzIKI057mvRNZsc2oaYWNyZCrCEE1RtNIythG6JkYT0RWnl2hVs@Phej9chvtrVLIurTqFsY8i3r8cY85virtb1tei82x2PHLOyQHHCAkOmFNHA1ImeKH9gpagaEI6xxpEcs9/7Yr6kv6gN@eLeVJ@kBeDMxrPEov/EHd/IOqAe0zdKBz/h/hNS2hqc9zgFaNv "Haskell – Try It Online")
The program is roughly equivalent to this Python code: [Try it online!](https://tio.run/##ZZDbbsMgDIbv8xSWpimJJrWAzWnS9i5JR9RITakCVZW@fGbSXuzABdgf/u0fLks@xjOu6zDHCdKSYJwucc6Q8le85qqawgQfgEYJgVpKrZGU8EaSQmuMKoFRWmn0gpxBoxV67ck4ZYTnRaTJu6JG7SRZpxyRlSS14zbWCi@FMOiIVSgUaR5lkZxCbb2Q3MkzN9L6qnp42t3mMYcm5blhc21b3Y7jKUAx@gnivQLo2LHis@ez4FfoOBsHBs8KgF@96t2ubjf8eG7Z9/tNBXCI5zyer4GTcErhIe//VvVdCszi/NXUXd3CC3i7XSxMe7ZQCjYQhyGFXD4Vt/zO4QJvT/7f3OE4N/f2p72@jC391vUb "Python 3 – Try It Online")
Unfolded code:
```
3 6 2 0 0 3 5 1 1 5 5
3 4 2 0 9 6 1 4 2 3 7 6
6 2 6 1 4 2 6 2 5 2 5 3 9
0 4 8 6 3 6 5 2 3 9 5 9 4 6
8 2 6 0 9 9 9 9 4 4 5 4 9 8 2
0 0 3 3 5 8 1 4 7 8 2 8 4 4 7 1
4 1 5 8 0 9 6 7 7 0 9 1 0 0 6 3 8
4 9 5 9 3 0 2 4 5 3 6 2 7 3 4 8 2 3
5 7 9 0 1 9 4 6 9 9 3 0 6 1 7 9 . . .
. / : { ; + ' = 1 P ' % ' a { : . . \ .
. . . . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . \
. . . . . . . . . . . . . \
! $ > < . . . . . . . . \
. . @ > { ? 2 ' % < . .
. . . . : ; ; 4 Q / .
```
Two `.`s takes 1 bit. Any other characters take 1 bit and a base-97 digit.
# Explanation
Click at the images for larger size. Each explanation part has corresponding Python code to help understanding.
### Data part
Instead of the complex structure used in some other answers (with `<`, `"` and some other things), I just let the IP pass through the lower half.
[](https://i.stack.imgur.com/qNCdC.png)
First, the IP runs through a lot of numbers and no-op's (`.`) and mirrors (`\`). Each digit appends to the number in the memory, so in the end the memory value is equal to the number at the start of the program.
```
mem = 362003511...99306179
```
`!` prints it,
```
stdout.write(str(mem))
```
and `$` jumps through the next `>`.
Starting from the `<`. If the memory value `mem` is falsy (`<= 0`, i.e., the condition `mem > 0` is not satisfied), we have done printing the program, and should exit. The IP would follow the upper path.
[](https://i.stack.imgur.com/JbSX5.png)
(let the IP runs ~~around the world~~ for about 33 commands before hitting the `@` (which terminates the program) because putting it anywhere else incurs some additional bytes)
If it's true, we follow the lower path, get redirected a few times and execute some more commands before hitting another conditional.
[](https://i.stack.imgur.com/cDsec.png)
```
# Python # Hexagony
# go to memory cell (a) # {
a = 2 # ?2
# go to memory cell (b) # '
b = mem % a # %
```
Now the memory looks like this:
[](https://i.stack.imgur.com/LXFfU.png)
If the value is truthy:
```
if b > 0:
```
the following code is executed:
[](https://i.stack.imgur.com/ykMH1.png)
```
# Python # Hexagony
b = ord('Q') # Q
b = b*10+4 # 4
# Note: now b == ord('.')+256*3
stdout.write(chr(b%256)) # ;
stdout.write(chr(b%256)) # ;
```
See detailed explanation of the `Q4` at [MartinEnder's HelloWorld Hexagony answer](https://codegolf.stackexchange.com/a/57600/69850). In short, this code prints `.` twice.
Originally I planned for this to print `.` once. When I came up with this (print `.` twice) and implement it, about 10 digits were saved.
Then,
```
b = mem // a # :
```
Here is a important fact I realized that saved me about 14 digits: You don't need to be at where you started.
---
To understand what I'm saying, let's have a BF analogy. (skip this if you already understood)
Given the code
```
while a != 0:
b, a = a * 2, 0
a, b = b, 0
print(a)
```
Assuming we let `a` be the value of the current cell and `b` be the value of the right cell, a straightforward translation of this to BF is:
```
[ # while a != 0:
[->++<] # b, a = a * 2, 0
>[-<+>] # a, b = b, 0
<. # print(a)
]
```
However, note that we don't need to be at the same position all the time during the program. We can let the value of `a` be whatever we are at the start of each iteration, then we have this code:
```
[ # while a != 0:
[->++<] # b, a = a * 2, 0
# implicitly let (a) be at the position of (b) now
. # print(a)
]
```
which is several bytes shorter.
---
Also, the corner wrapping behavior also saves me from having a `\` mirror there - without it I would not be able to fit the digits (+2 digits for the `\` itself and +2 digits for an unpaired `.` to the right of it, not to mention the flags)
(details:
* The IP enters the lower-left corner, heading left
* It get warped to the right corner, still heads left
* It encounters a `\` which reflects it, now it heads right-up
* It goes into the corner and get warped again to the lower-left corner
)
---
If the value (of the mod 2 operation above) is falsy (zero), then we follow this path:
[](https://i.stack.imgur.com/NCG9k.png)
```
# Python # Hexagony # Memory visualization after execution
b = mem // a # : # [click here](https://i.stack.imgur.com/s53S3.png)
base = ord('a') # 97 # a
y = b % base # '%
offset = 33 # P1
z = y + offset # ='+
stdout.write(chr(z)) # ; # [click here](https://i.stack.imgur.com/Dfalo.png)
mem = b // base # {: # [click here](https://i.stack.imgur.com/bdRHf.png)
```
I won't explain too detailed here, but the offset is actually not exactly `33`, but is congruent to `33` mod `256`. And `chr` has an implicit `% 256`.
[Answer]
# MySQL, 167 characters
```
SELECT REPLACE(@v:='SELECT REPLACE(@v:=\'2\',1+1,REPLACE(REPLACE(@v,\'\\\\\',\'\\\\\\\\\'),\'\\\'\',\'\\\\\\\'\'));',1+1,REPLACE(REPLACE(@v,'\\','\\\\'),'\'','\\\''));
```
That's right. :-)
I really did write this one myself. It was originally [posted at my site](https://joshduff.com/2008-11-29-my-accomplishment-for-the-day-a-mysql-quine.html).
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), ~~9.8e580~~ ~~1.3e562~~ ~~9.3e516~~ ~~12818~~ ~~11024~~ ~~4452~~ ~~4332~~ ~~4240~~ ~~4200~~ ~~4180~~ ~~3852~~ ~~3656~~ ~~3616~~ ~~3540~~ 2485 + 3 = 2488 bytes
*Now fits in the observable universe!*
```
(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(()()()()())(())(())(())(())(())(())(()())(())(())(())(()())(()()()())(())(()()()()())(()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(())(())(()())(())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()())(()())(())(()()()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(())(())(())(()()())(())(())(()()())(())(())(()()())(())(()()()()())(()())(()()()()())(()()())(())(()()())(())(())(())(()())(()()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(())(())(())(()()())(())(())(())(()())(())(()())(()()()())(())(())(()()()()())(()())(()())(())(()()())(())(())(())(())(()()())(()())(())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(()()()()())(()()()()())(())(()()())(())(())(()())(())(()()()()())(())(()()()()())(())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(()()()()())(())(()()()()())(())(())(())(()())(())(()()()()())(())(())(()())(())(()())(())(()())(()())(()())(()())(())(()()()()())(()())(())(()()()()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(())(()()())(())(())(())(()())(()()()())(())(())(()())(())(()()()()())(())(())(()()()()())(())(())(()()()()())(())(())(()())(())(()())(())(()())(())(()())(())(()())(()())(()())(()())(()())(()())(())(()()())(())(())(()())(())(()()()()())(()())(()()()()())(()()())(())(())(()())(())(())(()()()()())(()()()())(()())(()())(()()())(())(()())(())(()()()()())(()())(()()()()())(())(())(())(()()()())(()()()())(()())([[]]){({}()<(([{}]())<{({}())<>(((((()()()()()){}){}){}())[()])<>{({}())<>{}({}(((()()()){}())){}{})<>{({}())<>({}(((()()()()()){})){}{}())<>{{}<>({}(((()()()()){}){}){})(<>)}}<>(({})[()()])<>}}{}<>({}(<()>)<><{({}<>)<>}<>>){({}<>)<>}{}(<>)<>{({}<>)<>}{}(((((((()()()()()){}){}){}))()))>){({}()<((({}[()])()))>)}{}<>{({}<>)<>}{}>)}{}<>{({}<>)<>}<>
```
[Try it online!](https://tio.run/nexus/brain-flak#zVVBEoMgDLz3JcmhP2CY6TsYXsLwdhpIEaoE0KrTKgjrmmRhtQEAkVo8EErrzfPB4zXSY69b6949mQunjYzzfnO38ca1ztTSXo85bM9ovr9@3@r5lTnxdO/3FG390os662U5i@Tlnp@liO2q73Do2H8z@zTymlRlb9XPft/mdO39xoz2QVZ4TOteXVfp7Lv/376vv6iXn2u/B2f/e0nxjbEWHTgPqACM85ZQxQAqDelXojrPJw0NoCXGQqULnZnNHOqJXpFqSg6YSBzC@TVlyYigNPp4nwgxOaf3Pj@jADUBqXYVR9RrLLNI0Z9aFgQkgRgnqMvS0DUpZjhlrSNtIKUfIYTn6w0 "Brain-Flak – TIO Nexus")
---
## Explanation
This Quine works like most Quines in esoteric languages; it has two parts an encoder and a decoder. The encoder is all of the parentheses at the beginning and the decoder is the more complex part at the very end.
A naive way of encoding the program would be to put the ASCII value of every character in the decoder to the stack. This is not a very good idea because Brain-Flak only uses 8 characters (`()<>[]{}`) so you end up paying quite a few bytes to encode very little information. A smarter idea, and the one used up until now is to assign each of the 8 braces to an much smaller number (1-8) and convert these to the ASCII values with our decoder. This is nice because it costs no more than 18 bytes to encode a character as opposed to the prior 252.
However this program does neither. It relies on the fact that Brain-Flak programs are all balanced to encode the 8 braces with the numbers up to 5. It encodes them as follows.
```
( -> 2
< -> 3
[ -> 4
{ -> 5
),>,],} -> 1
```
All the close braces are assigned 1 because we can use context to determine which of them we need to use in a particular scenario. This may sound like a daunting task for a Brain-Flak program, but it really is not. Take for example the following encodings with the open braces decoded and the close braces replaced with a `.`:
```
(.
((..
<([.{...
```
Hopefully you can see that the algorithm is pretty simple, we read left to right, each time we encounter a open brace we push its close brace to an imaginary stack and when we encounter a `.` we pop the top value and put it in place of the `.`. This new encoding saves us an enormous number of bytes in the encoder while only losing us a handful of bytes on the decoder.
### Low level explanation
*Work in progress*
[Answer]
## GolfScript, 2 bytes
```
1
```
(note trailing newline) This pushes the number 1 onto the stack. At the end of the program, GolfScript prints out all items in the stack (with no spaces in between), then prints a newline.
This is a true quine (as listed in the question), because it actually executes the code; it doesn't just "read the source file and print it" (unlike the PHP submission).
---
For another example, here's a GolfScript program to print `12345678`:
```
9,(;
```
1. `9`: push 9 to the stack
2. [`,`](http://www.golfscript.com/golfscript/builtin.html#%2C): consume the 9 as an argument, push the array `[0 1 2 3 4 5 6 7 8]` to the stack
3. [`(`](http://www.golfscript.com/golfscript/builtin.html#%28): consume the array as an argument, push the array `[1 2 3 4 5 6 7 8]` and the item `0` to the stack
4. [`;`](http://www.golfscript.com/golfscript/builtin.html#%3B): discard the top item of the stack
The stack now contains the array `[1 2 3 4 5 6 7 8]`. This gets written to standard output with no spaces between the elements, followed by a newline.
[Answer]
# [Prelude](http://esolangs.org/wiki/Prelude), ~~5157~~ ~~4514~~ ~~2348~~ ~~1761~~ ~~1537~~ ~~664~~ ~~569~~ ~~535~~ ~~423~~ ~~241~~ ~~214~~ ~~184~~ ~~178~~ ~~175~~ ~~169~~ ~~148~~ ~~142~~ ~~136~~ 133 bytes
*Thanks to Sp3000 for saving 3 bytes.*
~~This is rather long...~~ (okay, it's still long ... at least it's beating the shortest ~~known Brainfuck~~ C# quine on this challenge now) *but* it's the first quine I discovered myself (my Lua and Julia submissions are really just translations of standard quine techniques into other languages) *and* as far as I'm aware no one has written a quine in Prelude so far, so I'm actually quite proud of this. :)
```
7( -^^^2+8+2-!( 6+ !
((#^#(1- )#)8(1-)8)#)4337435843475142584337433447514237963742423434123534455634423547524558455296969647344257)
```
That large number of digits is just an encoding of the core code, which is why the quine is so long.
The digits encoding the quine have been generated with [this CJam script](http://cjam.aditsu.net/#code=qW%25%7Bi2%2BAb%7D%2F&input=7(%20-%5E%5E%5E2%2B8%2B2-!(%206%2B%20!%0A%20%20((%23%5E%23(1-%20)%23)8(1-)8)%23)).
This requires a standard-compliant interpreter, which prints characters (using the values as character codes). So if you're using [the Python interpreter](http://web.archive.org/web/20060504072747/http://z3.ca/~lament/prelude.py) you'll need to set `NUMERIC_OUTPUT = False`.
## Explanation
First, a few words about Prelude: each line in Prelude is a separate "voice" which manipulates its own stack. These stacks are initialised to an infinite number of 0s. The program is executed column by column, where all commands in the column are executed "simultaneously" based on the previous stack states. Digits are pushed onto the stack individually, so `42` will push a `4`, then a `2`. There's no way to push larger numbers directly, you'll have to add them up. Values can be copied from adjacent stacks with `v` and `^`. Brainfuck-style loops can be introduced with parentheses. See the link in the headline for more information.
Here is the basic idea of the quine: first we push loads of digits onto the stack which encode the core of the quine. Said core then takes those digits,decodes them to print itself and then prints the digits as they appear in the code (and the trailing `)`).
This is slightly complicated by the fact that I had to split the core over multiple lines. Originally I had the encoding at the start, but then needed to pad the other lines with the same number of spaces. This is why the initial scores were all so large. Now I've put the encoding at the end, but this means that I first need to skip the core, then push the digits, and jump back to the start and do the printing.
### The Encoding
Since the code only has two voices, and and adjacency is cyclic, `^` and `v` are synonymous. That's good because `v` has by far the largest character code, so avoiding it by always using `^` makes encoding simpler. Now all character codes are in the range 10 to 94, inclusive. This means I can encode each character with exactly two decimal digits. There is one problem though: some characters, notably the linefeed, have a zero in their decimal representation. That's a problem because zeroes aren't easily distinguishable from the bottom of the stack. Luckily there's a simple fix to that: we offset the character codes by `2`, so we have a range from 12 to 96, inclusive, that still comfortably fits in two decimal digits. Now of all the characters that can appear in the Prelude program, only `0` has a 0 in its representation (50), but we really don't need `0` at all. So that's the encoding I'm using, pushing each digit individually.
However, since we're working with a stack, the representations are pushed in reverse. So if you look at the end of the encoding:
```
...9647344257
```
Split into pairs and reverse, then subtract two, and then look up the character codes:
```
57 42 34 47 96
55 40 32 45 94
7 ( - ^
```
where `32` is corresponds to spaces. The core does exactly this transformation, and then prints the characters.
### The Core
So let's look at how these numbers are actually processed. First, it's important to note that matching parentheses don't have to be on the same line in Prelude. There can only be one parenthesis per column, so there is no ambiguity in which parentheses belong together. In particular, the vertical position of the closing parenthesis is always irrelevant - the stack which is checked to determine whether the loop terminates (or is skipped entirely) will always be the one which has the `(`.
We want to run the code exactly twice - the first time, we skip the core and push all the numbers at the end, the second time we run the core. In fact, after we've run the core, we'll push all those numbers again, but since the loop terminates afterwards, this is irrelevant. This gives the following skeleton:
```
7(
( )43... encoding ...57)
```
First, we push a `7` onto the first voice - if we don't do this, we'd never enter the loop (for the skeleton it's only important that this is non-zero... why it's specifically `7` we'll see later). Then we enter the main loop. Now, the second voice contains another loop. On the first pass, this loop will be skipped because the second stack is empty/contains only 0s. So we jump straight to the encoding and push all those digits onto the stack. The `7` we pushed onto the first stack is still there, so the loop repeats.
This time, there is also a `7` on the second stack, so we do enter loop on the second voice. The loop on the second voice is designed such that the stack is empty again at the end, so it only runs once. It will *also* deplete the first stack... So when we leave the loop on the second voice, we push all the digits again, but now the `7` on the first stack has been discarded, so the main loop ends and the program terminates.
Next, let's look at the first loop in the actual core. Doing things simultaneously with a `(` or `)` is quite interesting. I've marked the loop body here with `=`:
```
-^^^2+8+2-!
(#^#(1- )#)
==========
```
That means the column containing `(` is not considered part of the loop (the characters there are only executed once, and even if the loop is skipped). But the column containing the `)` *is* part of the loop and is ran once on each iteration.
So we start with a single `-`, which turns the `7` on the first stack into a `-7`... again, more on that later. As for the actual loop...
The loop continues while the stack of digits hasn't been emptied. It processes two digits at a time,. The purpose of this loop is to decode the encoding, print the character, and at the same time shift the stack of digits to the first voice. So this part first:
```
^^^
#^#
```
The first column moves the 1-digit over to the first voice. The second column copies the 10-digit to the first voice while also copying the 1-digit back to the second voice. The third column moves that copy back to the first voice. That means the first voice now has the 1-digit twice and the 10-digit in between. The second voice has only another copy of the 10-digit. That means we can work with the values on the tops of the stacks and be sure there's two copies left on the first stack for later.
Now we recover the character code from the two digits:
```
2+8+2-!
(1- )#
```
The bottom is a small loop that just decrements the 10-digit to zero. For each iteration we want to add 10 to the top. Remember that the first `2` is not part of the loop, so the loop body is actually `+8+2` which adds 10 (using the `2` pushed previously) and the pushes another 2. So when we're done with the loop, the first stack actually has the base-10 value and another 2. We subtract that 2 with `-` to account for the offset in the encoding and print the character with `!`. The `#` just discards the zero at the end of the bottom loop.
Once this loop completes, the second stack is empty and the first stack holds all the digits in reverse order (and a `-7` at the bottom). The rest is fairly simple:
```
( 6+ !
8(1-)8)#
```
This is the second loop of the core, which now prints back all the digits. To do so we need to 48 to each digit to get its correct character code. We do this with a simple loop that runs `8` times and adds `6` each time. The result is printed with `!` and the `8` at the end is for the next iteration.
So what about the `-7`? Yeah, `48 - 7 = 41` which is the character code of `)`. Magic!
Finally, when we're done with that loop we discard the `8` we just pushed with `#` in order to ensure that we leave the outer loop on the second voice. We push all the digits again and the program terminates.
[Answer]
# Javascript ES6 - 21 bytes
```
$=_=>`$=${$};$()`;$()
```
I call this quine "The Bling Quine."
Sometimes, you gotta golf in style.
[Answer]
# Vim, 11 bytes
```
q"iq"qP<Esc>hqP
```
* `iq"qP<Esc>`: Manually insert a duplicate of the text that *has to be* outside the recording.
* `q"` and `hqP`: Record the inside directly into the unnamed `""` register, so it can be pasted in the middle. The `h` is the only repositioning required; if you put it inside the macro, it will be pasted into the result.
**Edit**
A note about recording with `q"`: The unnamed register `""` is a funny thing. It's not really a true register like the others, since text isn't stored there. It's actually a pointer to some other register (usually `"-` for deletes with no newline, `"0` for yanks, or `"1` for deletes with a newline). `q"` breaks the rules; it actually writes to `"0`. If your `""` was already pointing to some register other than `"0`, `q"` will overwrite `"0` but leave `""` unchanged. When you start a fresh Vim, `""` automatically points to `"0`, so you're fine in that case.
Basically, Vim is weird and buggy.
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), side length ~~15 14 13~~ 12, ~~616 533 456~~ 383 bytes
After several days of careful golfing, rearranging loops and starting over, I've *finally* managed to get it down to a side 12 hexagon.
```
1845711724004994017660745324800783542810548755533855003470320302321248615173041097895645488030498537186418612923408209003405383437728326777573965676397524751468186829816614632962096935858"">./<$;-<.....>,.........==.........<"......."">'....>+'\.>.........==........<"......"">:>)<$=<..>..............$..<"...."">\'Q4;="/@>...............<"....."">P='%<.>.............<"..!'<.\=6,'/>
```
[Try it online!](https://tio.run/##bcxNSsRAEAXgsxhGGnFM6r@qne7gEXSfjQvRlW719LEyGIXBBw3V1Ffv7eXz@fXj/WtdMUQd0UkApFYBdDNwUSYJAA9WoUBQCVdV5lAFYHFgAgZiwoSGis4gCNWjqknyyLXUUHYMk3xIlVggCOrWAMrBwu4UTObu6lxNzY2rK4krikXeBdVAs/wxVctrq6yhMQzzOLXD6a6NW@bjuKf337ENP0Pqcma3ZRnnf@guE97PN@3Qs/bPnXPYVZqlPMmpD9PDhdl7kjz2ct0uOrbtVWnj0u1YpnldvwE "Hexagony – Try It Online")
Unfolded:
```
1 8 4 5 7 1 1 7 2 4 0 0
4 9 9 4 0 1 7 6 6 0 7 4 5
3 2 4 8 0 0 7 8 3 5 4 2 8 1
0 5 4 8 7 5 5 5 3 3 8 5 5 0 0
3 4 7 0 3 2 0 3 0 2 3 2 1 2 4 8
6 1 5 1 7 3 0 4 1 0 9 7 8 9 5 6 4
5 4 8 8 0 3 0 4 9 8 5 3 7 1 8 6 4 1
8 6 1 2 9 2 3 4 0 8 2 0 9 0 0 3 4 0 5
3 8 3 4 3 7 7 2 8 3 2 6 7 7 7 5 7 3 9 6
5 6 7 6 3 9 7 5 2 4 7 5 1 4 6 8 1 8 6 8 2
9 8 1 6 6 1 4 6 3 2 9 6 2 0 9 6 9 3 5 8 5 8
" " > . / < $ ; - < . . . . . > , . . . . . .
. . . = = . . . . . . . . . < " . . . . . .
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
. . . . . . . . . $ . . < " . . . .
" " > \ ' Q 4 ; = " / @ > . . . .
. . . . . . . . . . . < " . . .
. . " " > P = ' % < . > . . .
. . . . . . . . . . < " . .
! ' < . \ = 6 , ' / > . .
. . . . . . . . . . . .
```
While it doesn't look like the most golfed of Hexagony code, the type of encoding I used is optimised for longer runs of no-ops, which is something you would otherwise avoid.
### Explanation
This beats the [previous Hexagony answer](https://codegolf.stackexchange.com/a/74294/76162) by encoding the no-ops (`.`) in a different way. While that answer saves space by making every other character a `.`, mine encodes the *number* of no-ops. It also means the source doesn't have to be so restricted.
Here I use a base 80 encoding, where numbers below 16 indicate runs of no-ops, and numbers between 16 and 79 represent the range 32 (`!`) to 95 (`_`) (I'm just now realising I golfed all the `_`s out of my code lol). Some Pythonic pseudocode:
```
i = absurdly long number
print(i)
base = 80
n = i%base
while n:
if n < 16:
print("."*(16-n))
else:
print(ASCII(n+16))
i = i//base
n = i%base
```
The number is encoded in the first half of the hexagon, with all the
```
" " >
" " >
... etc
```
on the left side and the
```
> ,
< "
>
< "
... etc
```
on the right side redirecting the pointer to encode the number into one cell. This is taken from [Martin Ender's answer](https://codegolf.stackexchange.com/a/74294/76162) (thanks), because I couldn't figure out a more efficient way.
It then enters the bottom section through the `->`:
```
" " > \ ' Q 4 ; = " / @ > . . . .
. . . . . . . . . . . < " . . .
. . " " > P = ' % < . > . . .
. . . . . . . . . . < " . .
-> ! ' < . \ = 6 , ' / > . .
```
`!` prints the number and `'` navigates to the right memory cell before starting the loop. `P='%` mods the current number by 80. If the result is 0, go up to the terminating `@`, else go down and create a cell next to the mod result with the value `-16`.
```
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
. . . . . . . . . $ . . < " . . . .
" " > \ ' Q 4 ; = " / @ > . . . .
/
/
```
Set the cell to (mod value + -16). If that value is negative, go up at the branching `>+'\`, otherwise go down.
If the value is positive:
```
" " > . / < $ ; - < . . . . . > , . . . . . .
. . . = = . . . . . . . . . < " . . . . . .
. " " > ' . . . . > + ' \ . > . . . . . .
```
The pointer ends up at the `;-<` which sets the cell to (mod value - -16) and print it.
The the value is negative:
```
. " " > ' . . . . > + ' \ . > . . . . . .
. . . = = . . . . . . . . < " . . . . .
. " " > : > ) < $ = < . . > . . . . .
```
Go down to the `> ) <` section which starts the loop. Here it is isolated:
```
. . > ) < $ = < . .
. . . . . . . . .
\ ' Q 4 ; = " /
```
Which executes the code `'Q4;="=` which prints a `.` (thanks again to Martin Ender, who wrote a [program](http://cjam.aditsu.net/#code=q%3AC%3B%27%5B%2C_el%5EA%2Cm*%7B_Ab256%25c%5C%2B%7D%25%7B0%3DC%26%7D%2C1f%3EN*&input=.) to find the letter-number combinations for characters) and moves back to the starting cell. It then increments (`)`) the mod value cell and loops again, until the mod value is positive.
When that is done, it moves up and joins with the other section at:
```
" " > . / < $ ; - < . . .
\
\
```
The pointer then travels back to the start of the larger loop again
```
" " > . / <--
. . . = =
. " " > '
. . . = =
. " " > :
. . . . .
" " > \ ' . .
. . . . . . .
. . " " > P = ' % < . > . . .
```
This executes `='=:'` which divides the current number by 80 and navigates to the correct cell.
### Old version (Side length 13)
```
343492224739614249922260393321622160373961419962223434213460086222642247615159528192623434203460066247203920342162343419346017616112622045226041621962343418346002622192616220391962343417346001406218603959366061583947623434"">/':=<$;'<.....>(......................<"......"">....'...>=\..>.....................<"....."">....>)<.-...>...........==......<"...."">.."...'.../>.................<"..."">\Q4;3=/.@.>...............<".."".>c)='%<..>..!'<.\1*='/.\""
```
[Try it online!](https://tio.run/##fY/NSgUxDIWfxaKMV7DT/DS38bbFV3A/GxHRlW716cekM4jixUJ/wvnOSfr6/PH48v72ua7ExIqIfCQVYGT1ShIpEYKg7USbBqpWozsQiCWl4rWwuwUyZM1YQFE2Jg1GxFR7q9ee6Bqoa2AuATAeE2fvyqaD7kwZflc902exlG/1OFTgZI7i82YlkWRzFFKbZ1Ah9Hm6a/XyNNXoq1/Hs6uG7TaDX5OjbbHjP3qH@6HG2/ibbe0nOcCw5879fJ5BywOfqM3x/k9fJ0KI/enQpqs6el3Ylxa4adMclxDW9Qs)
~~I can most definitely golf another side length off this, but I'll have to leave it til' tomorrow because it's getting late.~~ Turns out I'm impatient and can't wait until tomorrow. ~~Maybe another side can be golfed?~~ ~~:(~~ *ahhhhhhhhh* i did it!
I even golfed off a [couple of extra digits](https://tio.run/##fZPLTsMwEEX3@YoBFUUIMH7FcWhr8QMs2GfTBYIVbOHrw52x86S0o4ztyfHN9ST9ePs@vX99/gwDLX4tBfJkKCJbcpjxqq0WSAeoQbYYc@ZVoLiAAmpWqg0i4vKICEE9Ux7lFtnhCqQF1zJqChNmWBpiBtHgjhE5hwqHqyZXTopaJFtgTrZ68YfDFFBjO1e1uNbyaGa0PMbw/kw68efLITLgC@ow56N3gjZYtaVXnWSuWLEThDRsilkrXbHiIjc5Yh1xO8rRcj@zsBbRWI6bpceus7Sao0KqEYke6UA72tMDxhlIdL/Gy@yIUH/iAKU1Xab14kaiO6x6mW3gC@Ir6dzn0fkTrltxfyze0xY943W3lR2/hyzaI7@id3uIXqM5z7Po9IGpszFJzt@rmry@QK6mG/GZttglueX/6AolFughFvCCavhLW@gfd2oYfgE) with a base 77 encoding, but it doesn't really matter, since it has the same bytecount.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 20 bytes
```
3434Qu$v@!<"OOw\o;/"
```
*Almost got the* `\o/`...
**Net**:
```
3 4
3 4
Q u $ v @ ! < "
O O w \ o ; / "
. .
. .
```
# Try it online
Try it [here](https://ethproductions.github.io/cubix/?code=MzQzNFF1JC9AITwiT093XG87LyI=)!
# Additional notes
## Background story
After being impressed by reading [this great answer](https://codegolf.stackexchange.com/a/103532/63774) by @ais523, I started thinking about further golfing the quine. After all, there were quite a few no-ops in there, and that didn't feel very compressed. However, as the technique his answer (and mine as well) uses, requires the code to span full lines, a saving of at least 12 bytes was needed. There was one remark in his explanation that really got me thinking:
>
> On the subject of golfing down this quine further, [...] it'd need [...] some other way to represent the top face of the cube [...]
>
>
>
Then, suddenly, as I stood up and walked away to get something to drink, it struck me: What if the program didn't use character codes, but rather numbers to represent the top face? This is especially short if the number we're printing has 2 digits. Cubix has 3 one-byte instructions for pushing double-digit numbers: `N`, `S` and `Q`, which push `10`, `32` and `34` respectively, so this should be pretty golfy, I thought.
The first complication with this idea is that the top face is now filled with useless numbers, so we can't use that anymore. The second complication is that the top face has a size which is the cube size squared, and it needed to have an even size, otherwise one number would also end up on the starting position of the instruction pointer, leading to a polluted stack. Because of these complications, my code needed to fit on a cube of size 2 (which can contain 'only' 24 bytes, so I had to golf off at least 21 bytes). Also, because the top and bottom faces are unusable, I only had 16 effective bytes.
So I started by choosing the number that would become half of the top face. I started out with `N` (10), but that didn't quite work out because of the approach I was taking to print everything. Either way, I started anew and used `S` (32) for some reason. That did result in a proper quine, or so I thought. It all worked very well, but the quotes were missing. Then, it occured to me that the `Q` (34) would be really useful. After all, 34 is the character code of the double quote, which enables us to keep it on the stack, saving (2, in the layout I used then) precious bytes. After I changed the IP route a bit, all that was left was an excercise to fill in the blanks.
## How it works
The code can be split up into 5 parts. I'll go over them one by one. Note that we are encoding the middle faces in reverse order because the stack model is first-in-last-out.
### Step 1: Printing the top face
The irrelevant instructions have been replaced by no-ops (`.`). The IP starts the the third line, on the very left, pointing east. The stack is (obviously) empty.
```
. .
. .
Q u . . . . . .
O O . . . . . .
. .
. .
```
The IP ends at the leftmost position on the fourth line, pointing west, about to wrap around to the rightmost position on that same line. The instructions executed are (without the control flow character):
```
QOO
Q # Push 34 (double quotes) to the stack
OO # Output twice as number (the top face)
```
The stack contains just 34, representlng the last character of the source.
### Step 2: Encode the fourth line
This bit pretty much does what you expect it to do: encode the fourth line. The IP starts on the double quote at the end of that line, and goes west while pushing the character codes of every character it lands on until it finds a matching double quote. This matching double quote is also the last character on the fourth line, because the IP wraps again when it reaches the left edge.
Effectively, the IP has moved one position to the left, and the stack now contains the representation of the fourth line in character codes and reverse order.
### Step 3: Push another quote
We need to push another quote, and what better way than to recycle the `Q` at the start of the program by approaching it from the right? This has the added bonus that the IP directly runs into the quote that encodes the third line.
Here's the net version for this step. Irrelevant intructions have been replaced by no-ops again, the no-ops that are executed have been replaced by hashtags (`#`) for illustration purposes and the IP starts at the last character on the fourth line.
```
. .
. .
Q u $ . . . . .
. . w \ . . / .
. #
. #
```
The IP ends on the third line at the first instruction, about to wrap to the end of that line because it's pointing west. The following instructions (excluding control flow) are excecuted:
```
$uQ
$u # Don't do anthing
Q # Push the double quote
```
This double quote represents the one at the end of the third line.
### Step 4: Encoding the third line
This works exactly the same as step 2, so please look there for an explanation.
### Step 5: Print the stack
The stack now contains the fourth and third lines, in reverse order, so all we need to do now, it print it. The IP starts at the penultimate instruction on the third line, moving west. Here's the relevant part of the cube (again, irrelevant parts have been replaced by no-ops).
```
. .
. .
. . . v @ ! < .
. . . \ o ; / .
. .
. .
```
This is a loop, as you might have seen/expected. The main body is:
```
o;
o # Print top of stack as character
; # Delete top of stack
```
The loop ends if the top item is 0, which only happens when the stack is empty. If the loop ends, the `@` is executed, ending the program.
[Answer]
## Brainf\*ck (755 characters)
This is based off of a technique developed by Erik Bosman (ejbosman at cs.vu.nl). Note that the "ESultanik's Quine!" text is actually necessary for it to be a quine!
```
->++>+++>+>+>++>>+>+>+++>>+>+>++>+++>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>++>>>+++>>>>>+++>+>>>>>>>>>>>>>>>>>>>>>>+++>>>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>++>+++>>>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>>+++++++++++++++>+++++++++++++>++++++>+++++++++++++++>++++++++++>+++>+++>++++>++++++++++++++>+++>++++++++++>++++>++++++>++>+++++>+++++++++++++++>++++++++>++++>++++++++++++>+++++++++++++++>>++++>++++++++++++++>+++>+++>++++>++++++>+++>+++++++++>++++>+>++++>++++++++++>++++>++++++++>++>++++++++++>+>+++++++++++++++>+++++++++++++
ESultanik's Quine!
+[[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>>+[>]+++[++++++++++>++[-<++++++++++++++++>]<.<-<]
```
[Answer]
# Vim, ~~17~~, 14 keystrokes
Someone randomly upvoted this, so I remembered that it exists. When I re-read it, I thought "Hey, I can do better than that!", so I golfed two bytes off. It's still not the shortest, but at least it's an improvement.
---
For a long time, I've been wondering if a vim quine is possible. On one hand, it must be possible, since vim is turing complete. But after looking for a vim quine for a really long time, I was unable to find one. I *did* find [this PPCG challenge](https://codegolf.stackexchange.com/questions/2985/compose-a-vim-quine), but it's closed and not exactly about literal quines. So I decided to make one, since I couldn't find one.
I'm really proud of this answer, because of two *firsts*:
1. This is the first quine I have ever made, and
2. As far as I know, this is the worlds first *vim-quine* to ever be published! I could be wrong about this, so if you know of one, please let me know.
So, after that long introduction, here it is:
```
qqX"qpAq@q<esc>q@q
```
[Try it online!](https://tio.run/nexus/v#@19YGKFUWOBY6FAoDcT//wMA "V – TIO Nexus")
Note that when you type this out, it will display the `<esc>` keystroke as `^[`. This is still accurate, since `^[` represents `0x1B`, which is escape [in ASCII](http://www.asciitable.com/), and the way vim internally represents the `<esc>` key.
*Also* note, that testing this might fail if you load an existing vim session. I wrote a [tips](/questions/tagged/tips "show questions tagged 'tips'") answer explaining that [here](https://codegolf.stackexchange.com/a/74663/31716), if you want more information, but basically you need to launch vim with
```
vim -u NONE -N -i NONE
```
*or* type `qqq` before running this.
Explanation:
```
qq " Start recording into register 'q'
X " Delete one character before the cursor (Once we play this back, it will delete the '@')
"qp " Paste register 'q'
Aq@q<esc> " Append 'q@q' to this line
q " Stop recording
@q " Playback register 'q'
```
On a side note, this answer is probably a world record for most 'q's in a PPCG answer, or something.
[Answer]
# PostScript, 20 chars
Short and legit. 20 chars including trailing newline.
```
(dup == =)
dup == =
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 45 bytes
```
.....>...R$R....W..^".<R.!'.\)!'"R@>>o;?/o'u"
```
You can test this code [here](https://ethproductions.github.io/cubix/?code=Li4uLi4+Li4uUiRSLi4uLlcuLl4iLjxSLiEnLlwpISciUkA+Pm87Py9vJ3Ui&input=&speed=20).
This program is fairly hard to follow, but to have any chance to do so, we need to start by expanding it into a cube, like the Cubix interpreter does:
```
. . .
. . >
. . .
R $ R . . . . W . . ^ "
. < R . ! ' . \ ) ! ' "
R @ > > o ; ? / o ' u "
. . .
. . .
. . .
```
This is a Befunge-style quine, which works via exploiting wrapping to make string literals "wrap around" executable code (with only one `"` mark, the code is both inside and outside the quote at the same time, something that becomes possible when you have programs that are nonlinear and nonplanar). Note that this fits our definition of a proper quine, because two of the double quotes don't encode themselves, but rather are calculated later via use of arithmetic.
Unlike Befunge, though, we're using four strings here, rather than one. Here's how they get pushed onto the stack;
1. The program starts at the top of the left edge, going rightwards; it turns right twice (`R`), making it go leftwards along the third and last of the lines that wrap around the whole cube. The double quote matches itself, so we push the entire third line onto the stack backwards. Then execution continues after the double quote.
2. The `u` command does a U-turn to the right, so the next thing we're running is from `'"` onwards on the middle line. That pushes a `"` onto the stack. Continuing to wrap around, we hit the `<` near the left hand side of the cube and bounce back. When approaching from this direction, we see a plain `"` command, not `'"`, so the entire second line is pushed onto the stack backwards above the third line and the double quote.
3. We start by pushing a `!` onto the stack (`'!`) and incrementing it (`)`); this produces a double quote without needing a double quote in our source code (which would terminate the string). A mirror (`\`) reflects the execution direction up northwards; then the `W` command sidesteps to the left. This leaves us going upwards on the seventh column, which because this is a cube, wraps to leftwards on the third row, then downwards on the third column. We hit an `R`, to turn right and go leftwards along the top row; then the `$` skips the `R` via which we entered the program, so execution wraps round to the `"` at the end of the line, and we capture the first line in a string the same way that we did for the second and third.
4. The `^` command sends us northwards up the eleventh column, which is (allowing for cube wrapping) southwards on the fifth. The only thing we encounter there is `!` (skip if nonzero; the top of the stack is indeed nonzero), which skips over the `o` command, effectively making the fifth column entirely empty. So we wrap back to the `u` command, which once again U-turns, but this time we're left on the final column southwards, which wraps to the fourth column northwards. We hit a double quote during the U-turn, though, so we capture the entire fourth column in a string, from bottom to top. Unlike most double quotes in the program, this one doesn't close itself; rather, it's closed by the `"` in the top-right corner, meaning that we capture the nine-character string `...>.....`.
So the stack layout is now, from top to bottom: fourth column; top row; `"`; middle row; `"`; bottom row. Each of these are represented on the stack with the first character nearest the top of the stack (Cubix pushes strings in the reverse of this order, like Befunge does, but each time the IP was moving in the opposite direction to the natural reading direction, so it effectively got reversed twice). It can be noted that the stack contents are almost identical to the original program (because the fourth column, and the north/top face of the cube, contain the same characters in the same order; obviously, it was designed like that intentionally).
The next step is to print the contents of the stack. After all the pushes, the IP is going northwards on the fourth column, so it hits the `>` there and enters a tight loop `>>o;?` (i.e. "turn east, turn east, output as character, pop, turn right if positive"). Because the seventh line is full of NOPs, the `?` is going to wrap back to the first `>`, so this effectively pushes the entire contents of the stack (`?` is a no-op on an empty stack). We almost printed the entire program! Unfortunately, it's not quite done yet; we're missing the double-quote at the end.
Once the loop ends, we reflect onto the central line, moving west, via a pair of mirrors. (We used the "other side" of the `\` mirror earlier; now we're using the southwest side. The `/` mirror hasn't been used before.) We encounter `'!`, so we push an exclamation mark (i.e. 33; we're using ASCII and Cubix doesn't distinguish between integers and characters) onto the stack. (Conveniently, this is the same `!` which was used to skip over the `o` command earlier.) We encounter a pair of `R` commands and use them to make a "manual" U-turn (the second `R` command here was used earlier in order to reach the first row, so it seemed most natural to fit another `R` command alongside it.) The execution continues along a series of NOPs until it reaches the `W` command, to sidestep to the left. The sidestep crashes right into the `>` command on the second line, bouncing execution back exactly where it was. So we sidestep to the left again, but this time we're going southwards, so the next command to execute is the `)` (incrementing the exclamation mark into a double quote), followed by an `o` (to output it). Finally, execution wraps along the eighth line to the second column, where it finds a `@` to exit the program.
I apologise for the stray apostrophe on the third line. It doesn't do anything in this version of the program; it was part of an earlier idea I had but which turned out not to be necessary. However, once I'd got a working quine, I just wanted to submit it rather than mess around with it further, especially as removing it wouldn't change the byte count. On the subject of golfing down this quine further, it wouldn't surprise me if this were possible at 3×3 by only using the first five lines, but I can't see an obvious way to do that, and it'd need even tighter packing of all the control flow together with some other way to represent the top face of the cube (or else modifying the algorithm so that it can continue to use the fourth column even though it'd now be ten or eleven characters long).
[Answer]
# Python 2, 30 bytes
```
_='_=%r;print _%%_';print _%_
```
[Taken from here](https://web.archive.org/web/20130701215340/http://en.literateprograms.org/Quine_(Python))
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 261 bytes, side length 10
```
113009344778658560261693601386118648881408495353228771273368412312382314076924170567897137624629445942109467..../....%'=g':..\..................\.................\................\...............\..............\.............\............\!$/'?))='%<\..>:;/$;4Q/
```
[Try it online!](https://tio.run/##hYk7DsIwEETPgpTISmPvz7vrhMAZ6N1QoFBBC6c3pkbAaPSkN3O9PM7b/fZsDZEBCouYuWbPCqSohRWQXRFdxd1RwKVkzkzkZkjGrC5I3OudAqaFBA2ymhdDNiVRKiK5CCEUUYs96Y0xrFuYY6zxI/X/Un97/W51N6RwnKY1jPt@HOYlDYucUmsv "Hexagony – Try It Online")
Uses the same encoding [user202729's answer](https://codegolf.stackexchange.com/a/156271/76162), but terminates in a divide by zero error.
Formatted, this looks like:
```
1 1 3 0 0 9 3 4 4 7
7 8 6 5 8 5 6 0 2 6 1
6 9 3 6 0 1 3 8 6 1 1 8
6 4 8 8 8 1 4 0 8 4 9 5 3
5 3 2 2 8 7 7 1 2 7 3 3 6 8
4 1 2 3 1 2 3 8 2 3 1 4 0 7 6
9 2 4 1 7 0 5 6 7 8 9 7 1 3 7 6
2 4 6 2 9 4 4 5 9 4 2 1 0 9 4 6 7
. . . . / . . . . % ' = g ' : . . \
. . . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . . \
. . . . . . . . . . . . . . \
. . . . . . . . . . . . . \
. . . . . . . . . . . . \
! $ / ' ? ) ) = ' % < \
. . > : ; / $ ; 4 Q /
. . . . . . . . . .
```
[Try it online!](https://tio.run/##hZC9DsIwDIT3PsUhtapY6F@atEDhGdi7MKAywQpPH84mBAbU9iTbtb@cnFwvj/N0vz29R/wqqkFJ9cyGckkcOnSwaBlb5hI1YxXHVo9IXyyEFLMuiWPDpqhiVTIbHmjRBIAVDWv2HVWxcuyIYbAw2mxC7EItVg5WkZ49oRx7sqHs26tZ82EEsIy93q3VXBMotbJ6201QEasMOQZMjFv9H5M4mtP4YzZPLUOAXnGRemOLVMCW1ppDIoAVUj5WjiPW1MAqw/5nrviBb7cjljIanFB8x//svX8B "Hexagony – Try It Online")
Some python-like psuedo-code to explain:
```
n = ridiculously long number
base = 103
print(n)
while n > 0:
b = 2
if n%b == 1:
c = '.'
print(c)
else:
n = n//b
b = base
c = chr(n%b + 1)
print(c)
n = n//b
```
I'm using base 103 rather than the optimal base 97 just to make sure the number fully fits the top half of the hexagon and doesn't leave an extra `.` to encode.
Here's a [link](https://tio.run/##jZJPU4MwEMXv@RRPploilv7RE5Z60ItHp0frIUIgGSl0Qsb22@MmYMdTMZmE7L5fdl52UKL9klXVdXp/aIzFi7AiflbCMCbrrMklkgRba3RdYrbBa21lKc2v1lqkKDBBoSsrDcK6sbFutweRSU4qw1FJIxkxQYB@pFi4OJzG08Qty30Ni9sVoqWXMgX4PAN0gcU6zXWpLW5u4A/rT9FSUVgla4T@LlwKUa9zileky4py0piGnAXuUSJzLgNEEd4z9eG@AXQLso1vUek84HTNe@4rkTXbDI9G2JgcmeKYoSmKVlrG9kLXxGgiXHHqRKuaYxzuTrNNeLpDJevSqiGNE@dx3znGvN8Uy8U964u5oOuAeJjz8@kaUxJL2hMf79hZujQJ@yc1DgEOG6d6bJQasDFbl5AzgCtq75ya8wQO9y9NqWHrP7rHN9S7R8ImtD/gDfMf) to user202729's encoder that I used to get the large number and check that the number actually fit in the hexagon.
[Answer]
# C, ~~64~~ 60 bytes
```
main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}
```
This may segfault on 64-bit systems with some compilers, such as newest Clang, due to the type of `s` being interpreted as 32-bit `int` instead of a pointer.
So far, this is the shortest known C quine. There's an [extended bounty](https://codegolf.meta.stackexchange.com/a/12581/61563) if you find a shorter one.
This works in [GCC](https://tio.run/##S9ZNT07@/z83MTNPo1izuqAoM68kTaPYVglDRDVZtVjVUCVZx9hEp1jTulYJxvj/HwA), [Clang](https://tio.run/##S9ZNzknMS///PzcxM0@jWLO6oCgzryRNo9hWCUNENVm1WNVQJVnH2ESnWNO6VgnG@P8fAA), and [TCC](https://tio.run/##S9YtSU7@/z83MTNPo1izuqAoM68kTaPYVglDRDVZtVjVUCVZx9hEp1jTulYJxvj/HwA) in a [POSIX](https://en.wikipedia.org/wiki/POSIX) environment. It invokes an excessive amount of undefined behavior with all of them.
Just for fun, here's a [repo](https://github.com/aaronryank/quines/tree/master/c) that contains all the C quines I know of. Feel free to fork/PR if you find or write a different one that adds something new and creative over the existing ones.
Note that it only works in an [ASCII](https://en.wikipedia.org/wiki/ASCII) environment. [This](https://pastebin.com/raw/MESjTMQt) works for [EBCDIC](https://en.wikipedia.org/wiki/EBCDIC), but still requires [POSIX](https://en.wikipedia.org/wiki/POSIX). Good luck finding a POSIX/EBCDIC environment anyway :P
---
How it works:
1. `main(s)` abuses `main`'s arguments, declaring a virtually untyped variable `s`. (Note that `s` is not actually untyped, but since listed compilers auto-cast it as necessary, it might as well be\*.)
2. `printf(s="..."` sets `s` to the provided string and passes the first argument to `printf`.
3. `s` is set to `main(s){printf(s=%c%s%1$c,34,s);}`.
4. The `%c` is set to ASCII `34`, `"`. This makes the quine possible. Now `s` looks like this:
`main(s){printf(s="%s%1$c,34,s);}`.
5. The `%s` is set to `s` itself, which is possible due to #2. Now `s` looks like this:
`main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}%1$c,34,s);}`.
6. The `%1$c` is set to ASCII 34 `"`, `printf`'s first\*\* argument. Now `s` looks like this:
`main(s){printf(s="main(s){printf(s=%c%s%1$c,34,s);}",34,s);}`
... which just so happens to be the original source code.
\* [Example](https://tio.run/##S9ZNT07@/185My85pzQlVcGmuCQlM18vw46LKzOvRCE3MTNPoyw/M0WTq5pLAQhAghkKtgpKHqk5Ofk6CuH5RTkpikrWYMmC0pJijQxNa67a//8B) thanks to @Pavel
\*\* first argument after the format specifier - in this case, `s`. It's impossible to reference the format specifier.
---
I think it's impossible that this will get any shorter with the same approach. If `printf`'s format specifier was accessible via `$`, this would work for 52 bytes:
```
main(){printf("main(){printf(%c%0$s%1$c,34);}",34);}
```
---
Also here's a longer 64-byte version that will work on all combinations of compilers and ASCII environments that support the POSIX printf `$` extension:
```
*s;main(){printf(s="*s;main(){printf(s=%c%s%1$c,34,s);}",34,s);}
```
[Answer]
# [Lost](https://github.com/Wheatwizard/Lost), ~~120 116 98 96 76 70~~ 66 bytes
Edit: yay, under 100
Edit: Saved a bunch o' bytes by switching to all `/`s on the bottom line
```
:2+52*95*2+>::1?:[:[[[[@^%?>([ "
////////////////////////////////
```
[Try it online!](https://tio.run/##y8kvLvn/38pI29RIy9JUy0jbzsrK0N4q2ioaCBziVO3tNKIVlLj0CQCu////6zoCAA) + [verification it's deterministic for all possible states](https://tio.run/##y8kvLvn/38pI29RIy9JUy0jbzsrK0N4q2ioaCBziVO3tNKIVlLj0CQCu////6zoGAgA)
Lost is a 2D language in which the starting position and direction are completely random. This means there has to be a lot of error-checking at every stage to make sure you've got the correct instruction pointer, and it isn't one that has just wandered in randomly.
### Explanation:
All the `/`s on the bottom line are there to make sure that all the pointers that spawn in a vertical direction or on the bottom line get funneled in the right direction. From there, they end up at several different places, but all of them end up going right into the
```
^%?>
////
```
Which clears out all the non-zero numbers in the stack. The `([` after that clears out any extra 0s as well.
In the middle of the clear, it hits the `%`, which turns the 'safety' off, which allows the program to end when it hits the `@` (without this, the program could end immediately if a pointer started at the `@`).
From there it does a pretty simple 2D language quine, by wrapping a string literal (`"`) around the first line, pushing a `"` character by duping a space (`:2+`) and then a newline (`52*`). For the second line, it creates a `/` character (`95*2+`) and duplicates it a bunch (`>::1?:[:[[[[`), before finally ending at the `@` and printing the stack implicitly. The `?1` is to stop the process from creating too many 0s if the pointer enters early, saving on having to clear them later.
I saved 20 bytes here by making the last line all the same character, meaning I could go straight from the duping process into the ending `@`.
### Explanation about the duping process:
`[` is a character known as a 'Door'. If the pointer hits the flat side of a `[` or a `]` , it reflects, else it passes through it. Each time the pointer interacts with a Door, it switches to the opposite type. Using this knowledge we can construct a simple formula for how many times an instruction will execute in a `>:[` block.
Add the initial amount of instructions. For each `[`, add 2 times the amount of instructions to the left of it. For the example `>::::[:[[[`, we start with 5 as the initial amount. The first Door has 4 dupe instructions, so we add 4\*2=8 to 5 to get 13. The other three Doors have 5 dupes to their left, so we add 3\*(5\*2)=30 to 13 to get 43 dupe instructions executed, and have 44 `>`s on the stack. The same process can be applied to other instructions, such as `(` to push a large amount of items from the stack to the scope, or as used here, to clear items from the stack.
A trick I've used here to avoid duping too many 0s is the `1?`. If the character is 0, the `?` doesn't skip the 1, which means it duplicates 1 for the remainder of the dupe. This makes it *much* easier to clear the stack later on.
[Answer]
# [Chicken](http://esolangs.org/wiki/Chicken), 7
```
chicken
```
No, this is not directly echoed :)
[Answer]
## Cross-browser JavaScript (41 characters)
It works in the top 5 web browsers (IE >= 8, Mozilla Firefox, Google Chrome, Safari, Opera). Enter it into the developer's console in any one of those:
```
eval(I="'eval(I='+JSON.stringify(I)+')'")
```
It's not "cheating" — unlike Chris Jester-Young's single-byte quine, as it could easily be modified to use the `alert()` function (costing 14 characters):
```
alert(eval(I="'alert(eval(I='+JSON.stringify(I)+'))'"))
```
Or converted to a bookmarklet (costing 22 characters):
```
javascript:eval(I="'javascript:eval(I='+JSON.stringify(I)+')'")
```
[Answer]
# [Fission](http://esolangs.org/wiki/Fission), 6 bytes
It appears this is now the shortest "proper" quine among these answers.
```
'!+OR"
```
## Explanation
Control flow starts at `R` with a single right-going `(1,0)` atom. It hits `"` toggling print mode and then wraps around the line, printing `'!+OR` before hitting the same `"` again and exiting print mode.
That leaves the `"` itself to be printed. The shortest way is `'"O` (where `'"` sets the atom's mass to the character code of `"` and `O` prints the character and destroys the atom), but if we did this the `"` would interfere with print mode. So instead we set the atom's value to `'!` (one less than `"`), then increment with `+` and *then* print the result with `O`.
## Alternatives
Here are a couple of alternatives, which are longer, but maybe their techniques inspire someone to find a shorter version using them (or maybe they'll be more useful in certain generalised quines).
### 8 bytes using `J`ump
```
' |R@JO"
```
Again, the code starts at `R`. The `@` swaps mass and energy to give `(0,1)`. Therefore the `J` makes the atom jump over the `O` straight onto the `"`. Then, as before, all but the `"` are printed in string mode. Afterwards, the atom hits `|` to reverse its direction, and then passes through `'"O` printing `"`. The space is a bit annoying, but it seems necessary, because otherwise the `'` would make the atom treat the `|` as a character instead of a mirror.
### 8 bytes using two atoms
```
"'L;R@JO
```
This has two atoms, starting left-going from `L` and right-going from `R`. The left-going atom gets its value set by `'"` which is then immediately printed with `O` (and the atom destroyed). For the right-going atom, we swap mass and energy again, jump over the `O` to print the rest of the code in print mode. Afterwards its value is set by `'L` but that doesn't matter because the atom is then discarded with `;`.
[Answer]
## Java, 528 bytes:
A Java solution with an original approach:
```
import java.math.*;class a{public static void main(String[]a){BigInteger b=new BigInteger("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp",36);int i=0;for(byte c:b.toByteArray()){if(++i==92)System.out.print(b.toString(36));System.out.print((char)c);}}}
```
in readable form:
```
import java.math.*;
class a
{
public static void main (String [] a)
{
BigInteger b=new BigInteger ("90ygts9hiey66o0uh2kqadro71r14x0ucr5v33k1pe27jqk7mywnd5m54uypfrnt6r8aks1g5e080mua80mgw3bybkp904cxfcf4whcz9ckkecz8kr3huuui5gbr27vpsw9vc0m36tadcg7uxsl8p9hfnphqgksttq1wlolm2c3he9fdd25v0gsqfcx9vl4002dil6a00bh7kqn0301cvq3ghdu7fhwf231r43aes2a6018svioyy0lz1gpm3ma5yrspbh2j85dhwdn5sem4d9nyswvx4wmx25ulwnd3drwatvbn6a4jb000gbh8e2lshp", 36);
int i=0;
for (byte c:b.toByteArray ())
{
if (++i==92)
System.out.print (b.toString (36));
System.out.print ((char) c);
}
}
}
```
[Answer]
These are the two shortest **Ruby** quines [from SO](https://stackoverflow.com/questions/2474861/shortest-ruby-quine/2475931#2475931):
```
_="_=%p;puts _%%_";puts _%_
```
and
```
puts <<2*2,2
puts <<2*2,2
2
```
Don't ask me how the second works...
[Answer]
## [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~20~~ ~~14~~ ~~9~~ 7 bytes
Before we get started, I'd like to mention the trivial solution of a file which contains a single `0`. In that case Retina will try to count the `0`s in the empty input, the result of which is also `0`. I wouldn't consider that a proper quine though.
So here is a proper one:
```
>\`
>\`
```
[Try it online!](https://tio.run/##K0otycxLNPz/3y4mgQuI//8HAA "Retina – Try It Online")
Alternatively, we could use `;` instead of `>`.
### Explanation
The program consists of a single replacement which we print twice.
In the first line, the ``` separates the configuration from the regex, so the regex is empty. Therefore the empty string (i.e. the non-existent input) is replaced with the second line, verbatim.
To print the result twice, we wrap it in two output stages. The inner one, `\` prints the result with a trailing linefeed, and the outer one, `>`, prints it without one.
If you're a bit familiar with Retina, you might be wondering what happened to Retina's implicit output. Retina's implicit output works by wrapping the final stage of a program in an output stage. However, Retina doesn't do this, if the final stage is already an output stage. The reason for that is that in a normal program it's more useful to be able to replace the implicit output stage with special one like `\` or `;` for a single byte (instead of having to get rid of the implicit one with the `.` flag as well). Unfortunately, this behaviour ends up costing us two bytes for the quine.
[Answer]
## GolfScript, 8 bytes
I always thought the shortest (true) GolfScript quine was 9 bytes:
```
{'.~'}.~
```
Where the trailing linefeed is necessary because GolfScript prints a trailing linefeed by default.
But I just found an 8-byte quine, which works exactly around that linefeed restriction:
```
":n`":n`
```
[Try it online!](http://golfscript.tryitonline.net/#code=IjpuYCI6bmA&input=)
So the catch is that GolfScript doesn't print a trailing linefeed, but it prints the contents of `n` at the end of the program. It's just that `n` contains a linefeed to begin with. So the idea is to replace that with the string `":n`"`, and then stringifying it, such that the copy on the stack prints with quotes and copy stored in `n` prints without.
As pointed out by Thomas Kwa, the 7-byte CJam quine can also be adapted to an 8-byte solution:
```
".p"
.p
```
Again, we need the trailing linefeed.
[Answer]
# [Fueue](https://github.com/TryItOnline/fueue), 423 bytes
Fueue is a queue-based esolang in which the running program *is* the queue.
```
)$$4255%%1(~):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]](H-):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
```
[Try it online!](https://tio.run/##TU9bjsQgDLtMKzVTVRvzSAH1AHsHxOfsDeY3V@8mzKy0VFAnJrb5eT1fz/umZUkh53XFptS6lSGtK7erayOloX0BlPTqfV/ScaRa9sfR9AATtUGXjk5EOq4xtu@DmppIt18nbapbb0qPWS/Y9lSGwX2YgJIpqI6vsbdsStrGBpYYShU/geBnlIhTYpUqAAoq4NiYbEycCHZfQkAEo7IIPl2TwMSG@D3lKv94297zCjkF95cY2f0wl8Bx5OlRZssz5HcC03fn07wzcggsltdmIvu87fqXx7J6Pd2ct@nCJ9tkYBaWd5J5x9/gTLSPXdPZ@/4F "Fueue – Try It Online")
# How it works
This explanation ~~may or may not have~~ got way out of hand. On the other hand I don't know how to explain it *much* shorter in a way I hope people can follow.
## Fueue cheat sheet
See [esolang wiki article](https://esolangs.org/wiki/Fueue) for details, including the few features not used in this program.
* The initial program is the initial state of the queue, which can contain the following elements:
+ Integer literals (only non-negative in the source, but negative ones can be calculated), executing them prints a character.
+ Square-bracket delimited nested blocks, inert (preserved intact unless some function acts upon them).
+ Functions, their arguments are the elements following them immediately in the queue:
- `+*/-%`: integer arithmetic (`-` is unary, `%` logical negation). Inert if not given number arguments.
- `()<`: put element in brackets, remove brackets from block, add final element to block. The latter two are inert unless followed by a block.
- `~:`: swap, duplicate.
- `$`: copy (takes number + element). Inert before non-number.
- `H`: halt program.Note that while `[]` nest, `()` don't - the latter are simply separate functions.
## Execution trace syntax
Whitespace is optional in Fueue, except between numerals. In the following execution traces it will be used to suggest program structure, in particular:
* When a function executes, it and its arguments will be set off from the surrounding elements with spaces. If some of the arguments are complicated, there may be a space between them as well.
* Many execution traces are divided into a "delay blob" on the left, separated from a part to the right that does the substantial data manipulation. See next section.
Curly brackets `{}` (not used in Fueue) are used in the traces to represent the integer result of mathematical expressions. This includes negative numbers, as Fueue has only non-negative literals – `-` is the negation function.
Various metavariable names and `...` are used to denote values and abbreviations.
## Delaying tactics
Intuitively, execution cycles around the queue, partially modifying what it passes through. The results of a function cannot be acted on again until the next cycle. Different parts of the program effectively evolve in parallel as long as they don't interact.
As a result, a lot of the code is devoted to synchronization, in particular to delaying execution of parts of the program until the right time. There are a lot of options for golfing this, which tends to turn those parts into unreadable blobs that can only be understood by tracing their execution cycle by cycle.
These tactics won't always be individually mentioned in the below:
* `)[A]` delays `A` for a cycle. (Probably the easiest and most readable method.)
* `~ef` swaps the elements `e` and `f` which also delays their execution. (Probably the least readable, but often shortest for minor delays.)
* `$1e` delays a single element `e`.
* `-` and `%` are useful for delaying numbers (the latter for `0` and `1`.)
* When delaying several equal elements in a row, `:` or `$` can be used to create them from a single one.
* `(n` wraps `n` in brackets, which may later be removed at convenience. This is particularly vital for numeric calculations, since numbers are too unstable to even be copied without first putting them in a block.
## Overall structure
The rest of the explanation is divided into seven parts, each for a section of the running program. The larger cycles after which most of them repeat themselves will be called "iterations" to distinguish them from the "cycles" of single passes through the entire queue.
Here is how the initial program is divided between them:
```
A: )$$4255%%1(~
B: ):[)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
C:
D: (H-
E:
F:
G: ):~:[)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:](106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
```
The big numeral at the end of the program encodes the rest in reverse, two digits per character, with 30 subtracted from each ASCII value (so e.g. `10` encodes a `(`.)
On a higher level you can think of the data in this program (starting with the bignum) as flowing from right to left, but control flowing from left to right. However, at a lower level Fueue muddles the distinction between code and data all the time.
* Section G decodes the bignum into ASCII digits (e.g. digit `0` as the integer `48`), splitting off the least significant digits first. It produces one digit every 15 cycles.
* Section F contains the produced digit ASCII values (each inside a block) until section E can consume them.
* Section E handles the produced digits two at a time, pairing them up into blocks of the form `[x[y]]`, also printing the encoded character of each pair.
* Section D consists of a deeply nested block gradually constructed from the `[x[y]]` blocks in such a way that once it contains all digits, it can be run to print all of them, then halt the entire program.
* Section C handles the construction of section D, and also recreates section E.
* Section B recreates section C as well as itself every 30 cycles.
* Section A counts down cycles until the last iteration of the other sections. Then it aborts section B and runs section D.
## Section A
Section A handles scheduling the end of the program.
It takes 4258 cycles to reduce to a single swap function `~`, which then makes an adjustment to section B that stops its main loop and starts running section D instead.
```
)$ $4255% %1 (~
)$%%%...%% %0 [~]
)$%%%...% %1 [~]
⋮
)$ %0 [~]
) $1[~]
)[~]
~
```
* A `$` function creates 4255 copies of the following `%` while the `(` wraps the `~` in brackets.
* Each cycle the last `%` is used up to toggle the following number between `0` and `1`.
* When all `%`s are used up, the `$1` creates 1 copy of the `[~]` (effectively a NOP), and on the next cycle the `)` removes the brackets.
## Section B
Section B handles regenerating itself as well as a new iteration of section C every 30 cycles.
```
) : [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [)$$24%%0:<[~:)~)]~[$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] [BkB]
)$ $24% %0 :< [~:)~)] ~ [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] [BkB]
)$ %...%%% %1 < < [~:)~)] [BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...%% %0 < [~:)~)[BkB]] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
)$ %...% %1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
⋮
) $1 [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]]
) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
~:) ~)[BkB] [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]
) : [BkB] ) [$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<] (2)
) [BkB] [BkB] $11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<
```
* A `:` duplicates the big block following (one copy abbreviated as `[BkB]`), then `)` removes the brackets from the first copy.
* `$$24%%0` sets up a countdown similar to the one in section A.
* While this counts down, `:<` turns into `<<`, and a `~` swaps two of the blocks, placing the code for a new section C last.
* The two `<` functions pack the two final blocks into the first one - this is redundant in normal iterations, but will allow the `~` from section A to do its job at the end.
* (1) When the countdown is finished, the `)` removes the outer brackets. Next `~:)` turns into `):` and `~)` swaps a `)` to the beginning of the section C code.
* (2) Section B is now back at its initial cycle, while a `)` is just about to remove the brackets to start running a new iteration of section C.
In the final iteration, the `~` from section A appears at point (1) above:
```
~ ) [~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] (1)
[~:)~)[BkB][$11~)~<[[+$4--498+*-:~-10)):])<~][)))~]<]] )
```
The `~` swaps the `)` across the block and into section C, preventing section B from being run again.
## Section C
Section C handles merging new digit character pairs into section D's block, and also creating new iterations of section E.
The below shows a typical iteration with `x` and `y` representing the digits' ASCII codes. In the very first iteration, the incoming "D" and "E" elements are the initial `[H]` and `-` instead, as no previous section E has run to produce any digit character pairs.
```
C D E
$11~ ) ~<[[+$4--498+*-:~-10)):])<~] [)))~] < [)))~[...]] [x[y]]
~~~ ~~~ ~~~ ~~) [[+$4--498+*-:~-10)):])<~] < [)))~] [)))~[...][x[y]]]
~~~ ~~~ ) ~ [[+$4--498+*-:~-10)):])<~] [)))~[)))~[...][x[y]]]]
~~~ ~ ) [)))~[....]] [[+$4--498+*-:~-10)):])<~]
~~[)))~[....]] )[[+$4--498+*-:~-10)):])<~]
[)))~[....]] ~[+$4--498+*-:~-10)):])<~
```
* This uses a different method of synchronization which I discovered for this answer. When you have several swap functions `~` in a row, the row will shrink to approximately 2/3 each cycle (because one `~` swaps two following), but occasionally with a remainder of `~`s that ~~wreaks havoc on~~ carefully manipulates what follows.
* `$11~` produces such a row. The next `~` swaps a `<` across the following block. Another `<` at the end appends a new digit pair block (digits x and y as ASCII codes) into the section D block.
* Next cycle, the `~` row has a `~~` remainder, which swaps a `~` over the following `)`. The other `<` appends section D to a `[)))~]` block.
* Next the swapped `~` itself swaps the following block with new section E code across the section D block. Then a new leftover `~` swaps a `)` across, and finally the last `~~` in the `~` row swap one of them across to section E just as the `)` has removed its brackets.
In the final iteration, section A's `~` has swapped a `)` across section B and into section C. However, section C is so short-lived that it already has disappeared, and the `)` ends up at the beginning of section D.
## Section D
Section D handles printing the final big numeral and halting the program. During most of the program run, it is an inert block that sections B–G cooperate on building.
```
(H -
[H]-
⋮
[)))~[H-]] After one iteration of section C
⋮
[)))~[)))~[H-][49[49]]]] Second iteration, after E has also run
⋮
) [)))~[...]] [49[48]] Final printing starts as ) is swapped in
))) ~[...][49[48]]
)) )[49[48]] [...]
)) 49 [48][...] Print first 1
) )[48] [...]
) 48 [...] Print 0
)[...] Recurse to inner block
...
⋮
)[H-] Innermost block reached
H - Program halts
```
* In the first cycle of the program, a `(` wraps the halting function `H` in brackets. A `-` follows, it will be used as a dummy element for the first iteration instead of a digit pair.
* The first real digit pair incorporated is `[49[49]]`, corresponding to the final `11` in the numeral.
* The very last digit pair `[49[48]]` (corresponding to the `10` at the beginning of the numeral) is not actually incorporated into the block, but this makes no difference as `)[A[B]]` and `)[A][B]` are equivalent, both turning into `A[B]`.
After the final iteration, the `)` swapped rightwards from section B arrives and the section D block is deblocked. The `)))~` at the beginning of each sub-block makes sure that all parts are executed in the right order. Finally the innermost block contains an `H` halting the program.
## Section E
Section E handles combining pairs of ASCII digits produced by section G, and both prints the corresponding encoded character and sends a block with the combined pair leftwards to sections C and D.
Again the below shows a typical iteration with `x` and `y` representing the digits' ASCII codes.
```
E F
~ [+$4--498+*-:~-10)):] ) < ~ [y] [x]
) [+$4--498+*-:~-10)):] < [x] [y]
+ $4- - 498 +*- :~ -10 ) ) : [x[y]]
+--- -{-498} +*- ~~{-10} ) ) [x[y]] [x[y]]
+-- - 498 +* -{-10} ~ ) x [y] [x[y]]
+- -{-498} + * 10 x )[y] [x[y]]
+ - 498 + {10*x} y [x[y]]
+ {-498} {10*x+y} [x[y]]
{10*x+y-498} [x[y]]
[x[y]]
```
* The incoming digit blocks are swapped, then the y block is appended to the x block, and the whole pair block is copied. One copy will be left until the end for sections C and D.
* The other copy is deblocked again, then a sequence of arithmetic functions are applied to calculate `10*x+y-498`, the ASCII value of the encoded character. `498 = 10*48+48-30`, the `48`s undo the ASCII encoding of `x` and `y` while the `30` shifts the encoding from `00–99` to `30–129`, which includes all printable ASCII.
* The resulting number is then left to execute, which prints its character.
## Section F
Section F consists of inert blocks containing ASCII codes of digits. For most of the program run there will be at most two here, since section E consumes them at the same speed that G produces them with. However, in the final printing phase some redundant `0` digits will collect here.
```
[y] [x] ...
```
## Section G
Section G handles splitting up the big number at the end of the program, least significant digits first, and sending blocks with their ASCII codes leftward to the other sections.
As it has no halting check, it will actually continue producing `0` digits when the number has whittled down to 0, until section D halts the entire program with the `H` function.
`[BkG]` abbreviates a copy of the big starting code block, which is used for self-replication to start new iterations.
Initialization in the first cycles:
```
) :~ : [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ( 106328966328112328136317639696111819119696281563139628116326221310190661962811611211962861109696289611619628116111612896281115421063633063961111116163963011632811111819159628151213262722151522061361613096119619190661966311961128966130281807072220060611612811961019070723232022060611
) ~ ~ [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] [BkG] [10...11]
) [)[):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):]~:] ~ [BkG] [10...11]
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [10...11] [BkG]
```
Typical iteration, `N` denotes the number to split:
```
) [):~[)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+:5):] ~ : [N] [BkG]
) :~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/]+ :5 ) : [N] : [BkG]
) ~ ~ [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] +5 5 ) [N] [N] [BkG] [BkG]
) [)~:~~([:~)*[):~[$1(+48]):~+]-:~~)10)~~]/] ~ 10 N [N] [BkG] [BkG]
) ~:~ ~ ( [:~)*[):~[$1(+48]):~+]-:~~)10)~~] / N 10 [N] [BkG] [BkG]
) ~ : [:~)*[):~[$1(+48]):~+]-:~~)10)~~] ( {N/10} [N] [BkG] [BkG]
) [:~)*[):~[$1(+48]):~+]-:~~)10)~~] : [{N/10}] [N] [BkG] [BkG]
:~ )*[):~[$1(+48]):~+]- :~ ~)10 ) ~ ~ [{N/10}] [{N/10}] [N] [BkG] [BkG]
~~) *[):~[$1(+48]):~+]- ~~10 ) ) [{N/10}] ~ [{N/10}] [N] [BkG] [BkG]
) ~ * [):~[$1(+48]):~+] -10 ~ ) {N/10} [N] [{N/10}] [BkG] [BkG]
) [):~[$1(+48]):~+] * {-10} {N/10} ) [N] [{N/10}] [BkG] [BkG]
) :~ [$1(+48]) :~ + {-10*(N/10)} N [{N/10}] [BkG] [BkG]
) ~ ~ [$1(+48] ) ~ ~ {N%10} [{N/10}] [BkG] [BkG]
) [$1(+48] ~ ) {N%10} ~ [{N/10}] [BkG] [BkG]
$1( + 48 {N%10} ) [BkG] [{N/10}] [BkG]
( {48+N%10} BkG [{N/10}] [BkG] New iteration starts
[{48+N%10}] ....
```
* The delay blob here is particularly hairy. However, the only new delaying trick is to use `+:5` instead of `--10` to delay a `10` two cycles. Alas only one of the `10`s in the program was helped by this.
* The `[N]` and `[BkG]` blocks are duplicated, then one copy of `N` is divided by `10`.
* `[{N/10}]` is duplicated, then more arithmetic functions are used to calculate the ASCII code of the last digit of `N` as `48+((-10)*(N/10)+N)`. The block with this ASCII code is left for section F.
* The other copy of `[{N/10}]` gets swapped between the `[BkG]` blocks to set up the start of a new iteration.
# Bonus quine (540 bytes)
```
)$$3371%%1[~!~~!)!]):[)$$20%%0[):]~)~~[)$$12%%0[<$$7%~~0):~[+----48+*-~~10))]<]<~!:~)~~[40~[:~))~:~[)~(~~/[+--48):]~10]+30])):]]][)[H]](11(06(06(21(21(25(19(07(07(19(61(96(03(96(96(03(11(03(63(11(28(61(11(06(06(20(18(07(07(18(61(11(28(63(96(11(96(96(61(11(06(06(19(20(07(07(18(61(30(06(06(25(07(96(96(18(11(28(96(61(13(15(15(15(15(22(26(13(12(15(96(96(19(18(11(11(63(30(63(30(96(03(28(96(11(96(96(61(22(18(96(61(28(96(11(11(96(28(96(61(11(96(10(96(96(17(61(13(15(15(22(26(11(28(63(96(19(18(63(13(21(18(63(11(11(28(63(63(63(61(11(61(42(63(63
```
[Try it online!](https://tio.run/##VVBbjsMwCDxLpESCjaoFO2/lAL2D5c/2Bv3l6lnwo/FaIwsPzIB5f16f13Vh33u/8jBwkE6kwy7iEZR1NAwU8IiCIkawM@Ls@3UQITwkjA890zb@PESYEOMZT@mOJJhIgkYoWocCIr9WPm1myBRHTxE1jjFgeMYIzECLwXHCDLwDrQYNFoZds97uHFi9hyUFbrOC24GAt6qtKatJcuZi0kq0hapaiafqNhuZJZrKVkWu3ecbzoFbEunsWSR7USl0ALXNd/5FtmpHUhOu/t9sLrj7pidTbbH@G6aM0X45zWC78rbbEjdrKchDMkwuM9f1Bw "Fueue – Try It Online")
Since I wasn't sure which method would be shortest, I first tried encoding characters as two-digit numbers separated by `(`s. The core code is a bit shorter, but the 50% larger data representation makes up for it. Not as golfed as the other one, as I stopped when I realized it wouldn't beat it. It has one advantage: It doesn't require an implementation with bignum support.
Its overall structure is somewhat similar to the main one. Section G is missing since the data representation fills in section F directly. However, section E must do a similar divmod calculation to reconstruct the digits of the two-digit numbers.
[Answer]
# [Amazon Alexa](https://en.wikipedia.org/wiki/Amazon_Alexa), 31 words
```
Alexa, Simon Says Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says Alexa, Repeat That Alexa, Simon Says, Alexa, Repeat That Alexa, Simon Says
Alexa, Repeat That
Alexa, Simon Says quiet
```
(each command is on a newline)
When said out loud to a device with the Amazon Alexa digital assistant enabled (I've only tested this on the Echo Dot though), it should say the same words back to you. There will be some different lengths of pauses between words, as you wait for Alexa to reply, and it says everything without breaks, but the sequence of words are the same.
### Explanation:
Each line is a new Alexa command, one of either:
* `Alexa, Simon Says ...`, which will prompt Alexa to say everything afterward the command
* `Alexa, Repeat That`, which repeats the last thing Alexa said
(neither of these appear on most lists of Alexa commands, so I hope someone has actually learned something from this)
We can simplify this to the commands `S` and `R` respectively, separated by spaces. For example, `SR` will represent `Alexa, Simon Says Alexa, Repeat That`. The translation of our program would be:
```
SS R SRSRS R SQ
```
Where `Q` is `quiet` (but can be anything. I chose `quiet` because that's what Alexa produced when I tried to give it `quine`, and it fit, so I kept it). Step by step, we can map each command to the output of each command:
```
Commands: SS
Output: S
Commands: SS R
Output: S S
Commands: SS R SRSRS
Output: S S RSRS
Commands: SS R SRSRS R
Output: S S RSRS RSRS
Commands: SS R SRSRS R SQ
Output: S S RSRS RSRS Q
Total Commands: SSRSRSRSRSQ
Total Output: SSRSRSRSRSQ
```
The general approach for this was to get the output *ahead* of the input commands. This happens on the second to last command, which gets an extra `S` command. First we have to get behind on output though. The first two commands `SS R` only produce `SS`, leaving us to make up the `R`. However, this allows us to start a `S` command with an `R`, which means we can repeat a section (`RSRS`) multiple times, which allows us to get the spare `S` leftover. After that, all we had to do was use it to say whatever we wanted.
[Answer]
## Javascript (36 char)
```
(function a(){alert("("+a+")()")})()
```
This is, AFAICT, the shortest javascript quine posted so far.
[Answer]
# [Labyrinth](https://github.com/mbuettner/labyrinth), ~~124~~ ~~110~~ 53 bytes
*Thanks to Sp3000 for golfing off 9 bytes, which allowed me to golf off another 7.*
```
44660535853919556129637653276602333!
1
:_98
/8 %
@9_.
```
[Try it online!](http://labyrinth.tryitonline.net/#code=NDQ2NjA1MzU4NTM5MTk1NTYxMjk2Mzc2NTMyNzY2MDIzMzMhCjEKOl85OAovOCAlCkA5Xy4&input=)
## Explanation
Labyrinth 101:
* Labyrinth is a stack-based 2D language. The stack is bottomless and filled with zeroes, so popping from an empty stack is not an error.
* Execution starts from the first valid character (here the top left). At each junction, where there are two or more possible paths for the instruction pointer (IP) to take, the top of the stack is checked to determine where to go next. Negative is turn left, zero is go forward and positive is turn right.
* Digits in the source code don't push the corresponding number – instead, they pop the top of the stack and push `n*10 + <digit>`. This allows the easy building up of large numbers. To start a new number, use `_`, which pushes zero.
* `"` are no-ops.
First, I'll explain a slightly simpler version that is a byte longer, but a bit less magical:
```
395852936437949826992796242020587432!
"
:_96
/6 %
@9_.
```
[Try it online!](http://labyrinth.tryitonline.net/#code=Mzk1ODUyOTM2NDM3OTQ5ODI2OTkyNzk2MjQyMDIwNTg3NDMyIQoiCjpfOTYKLzYgJQpAOV8u&input=)
The main idea is to encode the main body of the source in a single number, using some large base. That number can then itself easily be printed back before it's decoded to print the remainder of the source code. The decoding is simply the repeated application of `divmod base`, where print the `mod` and continue working with the `div` until its zero.
By avoiding `{}`, the highest character code we'll need is `_` (95) such that base 96 is sufficient (by keeping the base low, the number at the beginning is shorter). So what we want to encode is this:
```
!
"
:_96
/6 %
@9_.
```
Turning those characters into their code points and treating the result as a base-96 number (with the least-significant digit corresponding to `!` and the most-significant one to `.`, because that's the order in which we'll disassemble the number), we get
```
234785020242697299628949734639258593
```
Now the code starts with a pretty cool trick (if I may say so) that allows us to print back the encoding and keep another copy for decoding with very little overhead: we put the number into the code in reverse. I computed the result [with this CJam script](http://cjam.aditsu.net/#code=qW%2596bsW%25&input=!%0A%22%0A%3A_96%0A%2F6%20%25%0A%409_.) So let's move on to the actual code. Here's the start:
```
395852936437949826992796242020587432!
"
```
The IP starts in the top left corner, going east. While it runs over those digits, it simply builds up that number on top of the stack. The number itself is entirely meaningless, because it's the reverse of what we want. When the IP hits the `!`, that pops this number from the stack and prints it. That's all there is to reproducing the encoding in the output.
But now the IP has hit a dead end. That means it turns around and now moves back west (without executing `!` again). This time, conveniently, the IP reads the number from back to front, so that now the number on top of the stack *does* encode the remainder of the source.
When the IP now hits the top left corner again, this is not a dead end because the IP can take a left turn, so it does and now moves south. The `"` is a no-op, that we need here to separate the number from the code's main loop. Speaking of which:
```
...
"
:_96
/6 %
@9_.
```
As long as the top of the stack is not zero yet, the IP will run through this rather dense code in the following loop:
```
"
>>>v
^< v
^<<
```
Or laid out linearly:
```
:_96%._96/
```
The reason it takes those turns is because of Labyrinth's control flow semantics. When there are at least three neighbours to the current cell, the IP will turn left on a negative stack value, go ahead on a zero and turn right on a positive stack value. If the chosen direction is not possible because there's a wall, the IP will take the opposite direction instead (which is why there are two left turns in the code although the top of the stack is never negative).
The loop code itself is actually pretty straightforward (compressing it this tightly wasn't and is where Sp3000's main contribution is):
```
: # Duplicate the remaining encoding number N.
_96 # Push 96, the base.
%. # Take modulo and print as a character.
_96 # Push 96 again.
/ # Divide N by 96 to move to the next digit.
```
Once `N` hits zero, control flow changes. Now the IP would like to move straight ahead after the `/` (i.e. west), but there's a wall there. So instead if turns around (east), executes the `6` again. That makes the top of the stack positive, so the IP turns right (south) and executes the `9`. The top of the stack is now `69`, but all we care about is that it's positive. The IP takes another right turn (west) and moves onto the `@` which terminates the code.
All in all, pretty simple actually.
Okay, now how do we shave off that additional byte. Clearly, that no-op seems wasteful, but we need that additional row: if the loop was adjacent to the number, the IP would already move there immediately instead of traversing the entire number. So can we do something useful with that no-op.
Well, in principle we can use that to add the last digit onto the encoding. The encoding doesn't really need to be all on the first line... the `!` just ensures that whatever *is* there also gets printed there.
There is a catch though, we can't just do this:
```
95852936437949826992796242020587432!
3
:_96
/6 %
@9_.
```
The problem is that now we've changed the `"` to a `3`, which also changes the actual number we want to have. And sure enough that number doesn't end in `3`. Since the number is completely determined by the code starting from `!` we can't do a lot about that.
*But* maybe we can choose another digit? We don't really care whether there's a `3` in that spot as long as we end up with a number that correctly encodes the source. Well, unfortunately, none of the 10 digits yields an encoding whose least-significant digit matches the chosen one. Luckily, there's some leeway in the remainder of the code such that we can try a few more encodings without increasing the byte count. I've found three options:
1. We can change `@` to `/`. In that case we can use any digit from `1357` and get a matching encoding. However, this would mean that the program then terminates with an error, which is allowed but doesn't seem very clean.
2. Spaces aren't the only "wall" characters. Every unused character is, notably all letters. If we use an upper case letter, then we don't even need to increase the base to accommodate it (since those code points are below `_`). 26 choices gives plenty of possibilities. E.g. for `A` any odd digit works. This is a bit nicer, but it still doesn't seem all that elegant, since you'd never use a letter there in real code.
3. We can use a greater base. As long as we don't increase the base significantly, the number of decimal digits in the encoding will remain the same (specifically, any base up to 104 is fine, although bases beyond 99 would actually require additional characters in the code itself). Luckily, base 98 gives a single matching solution: when we use the digit `1`, the encoding also ends in `1`. This is the only solution among bases 96, 97, 98, 99, so this is indeed very lucky. And that's how we end up with the code at the top of this answer.
[Answer]
# [Lost](https://github.com/Wheatwizard/Lost), ~~293~~ ~~262~~ 249 bytes
```
>:2+52*:6*:(84*+75*):>:::::[[[[[[[:[(52*)>::::[[[[[[:[84*+@>%?!<((((((((((([[[[[[[[[[[[[[ "
\#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\
```
[Try it online!](https://tio.run/##y8kvLvn/387KSNvUSMvKTMtKw8JES9vcVEvTys4KBKIhwCpaA6hA0w4hZBUNUulgp2qvaKOBANEoQEGJK0bZhlaAi0L9MVz////XdQQA "Lost – Try It Online")
## Explanation
This entire project has been an up and down. I kept thinking it was impossible and then coming up with a crazy idea that just might work.
Why is a Lost Quine so hard?
As you may know Lost is a 2D programming language where the start location and direction are entirely random. This makes writing any lost program about as difficult as writing radiation hardened code. You have to consider every possible location and direction.
That being said there are some standard ways to do things. For example here is the standard way of printing a string.
```
>%?"Stringv"(@
^<<<<<<<<<<<<<
```
This has a collection stream at the bottom that grabs the most of the ips and pulls them to the start location. Once they reach are start location (upper left) we sanitize them with a loop getting rid of all the values on the stack then turn the safety of push the string and exit. (safety is a concept unique to Lost every program must hit a `%` before exiting, this prevents the possibility of the program terminating upon start). Now my idea would be to extend this form into a full fledged quine.
The first thing that had to be done was to rework the loop a bit, the existing loop was specific to the String format.
```
>%?!<"Stringv"(@
^<<<<<<<<<<<<<<<
^<<<<<<<<<<<<<<<
```
We need to add a second stream to avoid the possibility of the `!` jumping over the stream and creating a loop.
Now we want to mix this with the standard Quine format. Since Lost is based very much on Klein I've ~~basically stolen~~ borrowed the Klien Quine for [Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender).
```
:2+@>%?!< "
<<<<^<<<<<<
<<<<^<<<<<<
```
This quite conveniently prints the first line of the quine. Now all we need to do is hard-code the streams. Well this is easier said than done. I tried approximately four different methods of doing this. I'll just describe the one that worked.
The idea here is to use doors to get the desired number of arrows. A Door is a special type of mirror that changes every time it is hit. `[` reflects ips coming from the left and `]` from the right. When they are hit by an ip from either of these sides the switch orientation. We can make a line of these doors and a static reflector to repeatedly perform an operation.
```
>:[[[
```
Will perform `:` three times. This way if we push a `<` to the stack before hand we can make a lot of them with less bytes. We make 2 of these, one for each line, and in between them we lay down a newline, however the second one needs only go until it covers the `!` we added it for, anything else can be left empty saving us a few bytes. Ok now we need to add the vertical arrows to our streams. This is where the key optimization comes in. Instead of redirecting all the ips to the "start" of the program directly we will instead redirect them to the far left, because we already know that the ips starting in far left *must* work (or at least will work in the final version) we can also just redirect the other ips. This not only makes it cheaper in bytes, I think this optimization is what makes the quine possible.
However there are still some problems, the most important one being ips starting after the `>` has been pushed but before we start making copies of it. Such ips will enter the copier and make a bunch of copies of 0. This is bad because our stack clearing mechanism uses zeros to determine the bottom of the stack, leaving a whole bunch of zeros at the bottom. We need to add a stronger stack sanitation method. Since there is no real way of telling if the stack is empty, we will simply have to attempt to destroy as many items on the stack as possible. Here we will once again use the door method described earlier. We will add `((((((((((([[[[[[[[[[[[[[` to the end of the first line right after the sanitizor to get rid of the zeros.
Now there is one more problem, since we redirected our streams to the upper left ips starting at the `%` and moving down will already have turned the safety off and will exit prematurely. So we need to turn the safety off. We do this by adding a `#` to the stream, that way ips flowing through the stream will be turned off but ips that have already been sanitized will not. The `#` must also be hard coded into the first line as well.
That's it, hopefully you understand how this works now.
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
**Want to improve this question?** [Update the question](/posts/2982/edit) so it's [on-topic](/help/on-topic) for Code Golf Stack Exchange.
Closed 12 years ago.
[Improve this question](/posts/2982/edit)
I'm not a 100% sure if this qualifies under this stack exchange; however, I asked [this question](https://stats.stackexchange.com/questions/5814/help-in-setting-up-and-solving-a-transportation-traffic-problem) on the stats stackexchange with no answers. I wonder if you can solve it:
[Traffic light synchronization](http://ops.fhwa.dot.gov/publications/fhwahop08024/chapter6.htm) nowadays is not a tedious project, Image:
For a personal research project I'm trying to build a statistical model to solve such problems in two and higher dimensions.
I would like to synchronize `x` 4 legged (approaches) intersections such that:
* The intersections are all located within the same area in a grid type format. I'd like to think of this as a 1/0 matrix, where 1 indicates a signalized intersection and 0 doesn't:
**Matrix Example**
[1 1 1 1]
[0 1 0 1]
[1 1 1 1]
This assumes that all nodes are connected in a vertical or horizontal but not diagonal manner and that they could have a direction of either one or two way.
* Each Intersection has a traffic light on each approach
* The allowable movements per leg are left, right, and Through (lrt) and no U-Turns
* Each Leg can be one lane, i.e. one lane that allows for lrt or approaches can have combined, through and right (1 lane), and left (1 lane, or dedicated such as alpha left lanes, beta through lanes, and gamma right lanes. Some intersections should allow for restricted or no movement, as in an intersection could be setup as "no-left turns allowed"
* Each lane should have a distinct vehicle flow (vehicles / minutes (Time)) per movement, so a two lane (left + through, and right) approach could have the following movement:
Left + Through lane: 10 vehicles / minute (through) and 5 vehicles per minute turning left
Right lane: 15 vehicles per minute
* Assume green cycle time (time from beginning of green to beginning second green to depend on the vehicle volumes, yet could only be between t1 and t2 seconds. Green time = red time + yellow time). Yellow time should be assumed as a constant either 1, 2, or 3 seconds (depending on the jurisdiction). if pedestrian crossing is warranted, the red time should be assumed to be "white go ped: 4 seconds x lane" + "blinking ped: 4 seconds x lane". remember that the number of lanes would be from the opposing approaches combined.
* The system should optimize green time so that maximum flow is passed through the system at all intersections depending no the existing volumes **and** on historical values.
* Although there are historical data on the number of vehicles that enter the green network, I assume it is best to use a Monte Carlo simulation to simulate vehicle entry into the system and then calibrated to historical data.
* The end result should be an equation or system of equations that will give you the green time for each intersection depending on volumes and what to expect from the other intersections.
I know this might not be the clearest question, but I'm happy to answer any questions and or comments.
]
|
[Question]
[
# Task
Take in **3** inputs. The **length** of the wall, the **height** of the wall and the **coverage** of the paint. Output how many tins of paint are required.
# Output
Since there's no way to purchase `1/3` tin of paint, you'll need to round the amount of paint tins up to the nearest integer.
# Assumptions/Stipulations
* Only 1 coat of paint is required
* Round up in terms of paint tins required
# Test Cases
>
> Length: 20 meters | Height: 7 meters | Coverage: 12 meters = 12 tins of paint
>
>
>
| Input | Output |
| --- | --- |
| `1/1/10` | `1` |
| `5/5/10` | `3` |
| `2/3/8` | `1` |
| `5/8/8` | `5` |
| `45/5/18` | `13` |
| `20/7/12` | `12` |
| `1/1/1` | `1` |
| `200/10/14` | `143` |
## Current Winners! (28th November 2023)
Jelly - 3 bytes - Jonathan Allan
<https://codegolf.stackexchange.com/a/267131/91342>
Uiua - 3 bytes - chunes
<https://codegolf.stackexchange.com/a/267109/91342>
Vyxal 3 - 3 bytes - Nick Kennedy
<https://codegolf.stackexchange.com/a/267138/91342>
APL - 3 bytes - Tbw
<https://codegolf.stackexchange.com/a/267134/91342>
Vyxal - 3 bytes - Iyxal
<https://codegolf.stackexchange.com/a/267112/91342>
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
P÷Ċ
```
A monadic Link that accepts the dimensions on the left and the paint tin coverage on the right and yields the number of tins required.
**[Try it online!](https://tio.run/##y0rNyan8/z/g8PYjXf8PL3@4c5Xm///R0QoKhjpgbGgQq8OlAOSb6oAxnG8E5BsDsQWSvAWCbwJTD@UbGQD55kC@EVQ91HwFQzDfyMAAZDYQmwD5sQA "Jelly – Try It Online")**
### How?
```
P÷Ċ - Link: Dimensions, Coverage
P - product {Dimensions}
÷ - divide by {Coverage}
Ċ - ceiling
```
[Answer]
# [Uiua](https://uiua.org), ~~4~~ 3 [bytes](https://codegolf.stackexchange.com/a/265917/97916)
```
⌈×÷
```
[Try it!](https://uiua.org/pad?src=0_3_1__ZiDihpAg4oyIw5fDtwoKZiAxMCAxIDEKZiAxMCA1IDUKZiA4IDIgMwpmIDggNSA4CmYgMTggNDUgNQpmIDEyIDIwIDcKZiAxIDEgMQpmIDE0IDIwMCAxMAo=)
-1 thanks to alephalpha
Takes input in the order `coverage length height`
```
⌈×÷
÷ # divide first two args
× # multiply by third
⌈ # ceiling
```
[Answer]
# [Vyxal 3](https://github.com/Vyxal/Vyxal/tree/version-3), 3 bytes
```
÷×⌈
```
[Try it Online!](https://vyxal.github.io/latest.html#WyIiLCIiLCLDt8OX4oyIIiwiIiwiMTBcbjIwMFxuMTQiLCIzLjEuMCJd)
Similar to most other answers. Divide by coverage, multiply by other dimension, take ceiling.
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 3 bytes
```
⌈÷/
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhEc9HYe36///X5JaXFIM5GsYKhgaKBhqapiCaFNNDSMFCwVjENdCwUJTwwQobAEWBioyUjDXBKkHKTcyAAqYAPVocoGN0ok21DONTTu0AswDAA "APL (Dyalog Classic) – Try It Online")
Written as a tacit function that takes a vector with entries length, coverage, and height, in that order.
`÷/`, read as Divide Reduce, calculates `length ÷ coverage ÷ height`. Since APL evaluates right to left, this gives `length ÷ (coverage ÷ height) = (length × height) ÷ coverage`. `⌈` takes the ceiling of the result.
[Answer]
# APL+WIN, 6 bytes
Prompts for three numbers. Coverage followed by wall dimensions:
```
⌈⎕×⎕÷⎕
```
[Try it online! Thanks to Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcQJanP5BlyPWooz3t/6OeDqDI4ekgYjuQ@A8U5fqfxmVoAEZcYJYpEKZxWXAZcxmBaQsw3xBEmYBZRlzmXEYGIBYYAmkTkD4jAwMuAA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Arturo](https://arturo-lang.io), 15 bytes
```
$=>[ceil//&*&&]
```
[Try it!](http://arturo-lang.io/playground?TRHAvo)
```
$=>[ceil//&*&&]
$=>[ ] ; a function
&*& ; multiply first arg by second
// & ; divide by third
ceil ; ceiling
```
[Answer]
# [Scala 3](https://www.scala-lang.org/), 20 bytes
```
(l,h,c)=>(l*h+c-1)/c
```
[Attempt This Online!](https://ato.pxeger.com/run?1=bZA9CsJAEIX7nOKVu7rBJEYMAQVLCyuxEot1NRpZV0lWQUJOYpNGT-BlchQ7N0YbDcwPvI95M8z1ngouebco3cNytxYaEx4rZJYFnLlEFBKQsdIM30IHw6pigNtJR3bwIJJtmTAyka1tW9gu7YgalU9gtY6wN5aEJ5s0xChJ-GU-1UmsNgsaYqZibawysw44GlVLRSLiMlThUPoDegy9RuAxdBmCpoGgSfc_Tv_Ecxj6hnh_5HNVw4RT3WTSf7PcyusHFEXdXw)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
Ｉ±÷×ＮＮ±Ｎ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwy81PbEkVcMzr8QlsywzJVUjJDM3tRjILygt8SvNTUot0tDUUUDhAvlwXcjCIGD9/7@RAZc5l6HRf92yHAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Port of @SevC\_10's Python answer.
```
Ｎ First input as a number
× Multiplied by
Ｎ Second input as a number
÷ Integer divided by
Ｎ Third input as a number
± Negated
± Negated
Ｉ Cast to string
Implicitly print
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 39 bytes
```
.+
$*
1(?=1*¶(1+)¶)
$1
(1+)(?=1*¶1+¶\1)
```
[Try it online!](https://tio.run/##K0otycxL/K@qEZyg819Pm0tFi8tQw97WUOvQNg1Dbc1D2zS5VAy5QEyoqKH2oW0xhpr//xvqAKEBl6mOKYgy0jHWsQByLICkCVjMgsvIQMdcx9CIC6wSyDMAKtQxNAEA "Retina 0.8.2 – Try It Online") Takes input on separate lines but link is to test suite that splits on commas for convenience. Explanation:
```
.+
$*
```
Convert to unary.
```
1(?=1*¶(1+)¶)
$1
```
Multiply only the first number by the second.
```
(1+)(?=1*¶1+¶\1)
```
Partition the first number into as few values as possible that do not exceed the third number and output the size of the partition.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 22 bytes
```
(a,b,c)=>(a*b+c-1)/c|0
```
[Try it online!](https://tio.run/##TY7BDoIwEETP9is8bm1h2wKRxOCXEKWUQjBICRhP/nstEBOzh30zs5PsQ7/1YuZ@ekWja6xvCw@a19zQ4gr6VDMTSYrmI/ylIhLDiONBkgyzjRKiMMF8t/IVMpJu4eqFVOAZpQqs9vZ6qYQIZZRpEGlSxbOdBm0s4A3KhtES/xc@Ow53/vvJuHFxg40H10ELTHNWc2Yopf4L "JavaScript (Node.js) – Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 20 bytes suggested by Arnauld
```
(x,y,z)=>~-(x*y+z)/z
```
[Try it online!](https://tio.run/##fc/LCsIwEAXQfb8iy0Sn5o3d1H8ptRWlTMSKtFn469FIQFIfMMvDvXNPza0Z28vxfC3R7bvQ14FOMINn9e5e0mk1rz3jPrQORzd0m8EdaE8lQjyBhBDGCOdEFrmwCDYXeiEUgkaoIvidUeXCLoRJNdGkjI8agbB9EvUmqvi65s8nSojXGJAGkzA6PAA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), ~~25~~ 23 bytes
```
lambda l,h,c:-(-l*h//c)
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPqfZhvzPycxNyklUSFHJ0Mn2UpXQzdHK0NfP1nzf0FRZl6JRpqGoQ4QGmhqcsEETHVMUQWMdIx1LFAUWKDwTcA6kEWMDHTMdQyNkETAtqCoMABaomNooqn5HwA "Python 3.8 (pre-release) – Try It Online")
---
Edit
* -2 bytes thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 5 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
×/V c
```
[Try it here](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=1y9WIGM&input=WzQ1IDVdCjE4)
[Answer]
# [sclin](https://github.com/molarmanful/sclin), 6 bytes
```
/ * |^
```
[Try it on scline!](https://scline.fly.dev/#H4sIANZhZWUCA4s2VABCg1g9rmhTBVMoy1jBSMECxLAACoEZpgomQEkw01zByEDB0AjEBOsFMwyAgkBREyBHJ0FBQ0EnXk9BUyE3sQAAADFLcmAAAAA#H4sIANZhZWUCA9NX0FKoiQMA93pifgYAAAA#) Takes input as `H L C`.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `r`, 3 bytes
```
*/⌈
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyJyIiwiIiwiKi/ijIgiLCIiLCI1XG41XG4xMCJd)
Hehehehe flag go brrrr
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 40 bytes
```
param($l,$h,$c)[math]::Ceiling($l*$h/$c)
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmZb/b8gsSgxV0MlR0clQ0clWTM6N7EkI9bKyjk1MyczLx0ooaWSoQ@U@F/LxaWmkqZgCIIGYKYpEEKZRgrGChZQQQsoywQsD2EbGSiYKxgaIUyAihoADVAwNOH6DwA "PowerShell – Try It Online")
Thanks [Julian](https://codegolf.stackexchange.com/users/97729/julian)!
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 47 bytes
```
$c={param($l,$h,$c)[math]::Ceiling(($l*$h)/$c)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyXZtrogsSgxV0MlR0clQ0clWTM6N7EkI9bKyjk1MyczL10DKKOlkqGpD5SqBarX88wry89O1TDUUQAhA00uhJipjoIpupiRjoKxjoIFmjILNCETqFYUQSMDHQVzoKARsiDUXlR1BiBbgdhE8z8A "PowerShell – Try It Online")
Thought I'd throw my own suggestion in :-)
[Answer]
# Google Sheets, 18 bytes
```
=roundup(A1*B1/C1)
```
Put the input in cells `A1:C1`.
In Microsoft Excel, `roundup()` requires a second parameter (**19 bytes**):
```
=roundup(A1*B1/C1,)
```
[Answer]
# [ARBLE](https://github.com/TehFlaminTaco/ARBLE), 11 bytes
```
ceil(l*h/c)
```
Not the most imaginative answer.
Arguments as `coverage, height, length`
[Try it online!](https://tio.run/##SyxKykn9/z85NTNHI0crQz9Z8////4Ym/w0N/hsZGAAA "ARBLE – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
/*î
```
Inputs in the order \$coverage,length,height\$.
[Try it online](https://tio.run/##yy9OTMpM/f9fX@vwuv//DY24jAy4zAE) or [verify all test cases](https://tio.run/##yy9OTMpM/V9WmVCklJxfllqUmJ5qpXB4v7VCSmZual5xZn5eMYhfcXi/wqO2SQpK9kCV//W1Dq/7r/M/OtrQQMdQxzBWB8Qw1TEFMix0jHSMwbSpjgVIwkLHBCJjaKRjZKBjDmLBNJkARYAmGMTGAgA).
**Explanation:**
```
/ # Divide the second (implicit) input length by the first (implicit) input coverage
* # Multiply it to the third (implicit) input height
î # Ceil it
# (after which the result is output implicitly)
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 3 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
*́
```
Inputs (as floats) in the same order as the challenge description: \$length,height,coverage\$.
[Try it online.](https://tio.run/##y00syUjPz0n7/1/r0dQFh/f8/2@oZ6AAxgZ6BlymQIYpjGMEZBgDsQVUwgLKNoGrAvGMgEoVzEE8oHouuGlgGQOoUQqGJnoGAA)
**Explanation:**
```
* # Multiply the first two (implicit) inputs: height*length
╠ # Divide it by the third (implicit) input: (height*length)/coverage
ü # Ceil it
# (after which the entire stack is output implicitly as result)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~27~~ 24 bytes
```
f(l,h,c){l=(l*h+c-1)/c;}
```
[Try it online!](https://tio.run/##bVHtaoNAEPyfp1iEgMaT@JHQFmv/lD5FlSKbMye9aPCESsVXr707TzFtxF3XnZldnUPvjDiOhc0JI@j0PLH5jrnoBc4e42EsqxYueVnZDvQbkJdqtFS0H/w9gwT6gMCRQKjzQVU@gUA9/CG@FbC1ICLwqIsHTQ/@sdGw1Thfk@UdqAgnxWGloN2VYktPy4ZIc@T4IFopIiPBuhItIMubncwUP2kzKa20ewvT7ulVxtEisH6PLKMu6gZstbWsTrSTMj825TOI8pvWhT1/j7M3jd3SicF1NdvRwyZT5//gcpoxV3Oy@AZmM8zuwjjDeBcWElbnDIwAOrcYldhi4l/xtZGUwra2JwJTgPei8laklXTJjCQgyGKnSBKamSXDZhh/sOD5WYze1@jxyy8 "C (gcc) – Try It Online")
*Saved 3 bytes thanks to [Sisyphus](https://codegolf.stackexchange.com/users/48931/sisyphus)!!!*
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 34 bytes
```
K.Q)=+Z*@K0@K1;J0;W>Z0=-Z@K2=+J1;J
```
[Try it online!](https://tio.run/##K6gsyfj/31svUNNWO0rLwdvAwdvQ2svAOtwuysBWN8rB28hW2wso8v@/kYEBlyEQmQAA "Pyth – Try It Online")
I just wanted to try out in `Pyth`. Unfortunately, `Pyth` doesn't support float division so, had to use `while` to do the trick.
#### Explanation
**K.Q)** - get input in a newline, as in the question's order and store it as `list` in `K`
**<Z** - used to store the product of `length` and `height` i.e `area`
**W>Z0=-Z@K2=+J1** - used to iterate until the area isn't `0` and decrement the `area` by `coverage` (`@K2`); and increment `J` by `1`
] |
[Question]
[
Write code that outputs the smallest integer \$n > 5\$ such that \$\frac{\sqrt{\log\_2{n}}}{(\log\_2 {\log\_2 n})^2} > 1\$. Your code may have at most one digit in its source code. You can use your chosen digit more than once however.
By digits we are only counting the ASCII characters between 0x30 and 0x39 (inclusive).
[Answer]
# [Python](https://www.python.org), 22 bytes
```
print(-~2**2**2**2**2)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwU3dzNyC_KISheLKYi4g1itOLYnPzCuJz02siC8uKYpPyUzPLCnWMDQAAc2lpSVpuhbbCoqASjR064y0tBAIKrkASkFpAA)
[According to WolframAlpha](https://www.wolframalpha.com/input?i=sqrt%28log2%28x%29%29%2Flog2%28log2%28x%29%29%5E2%3D1), the equation \$\sqrt{\log\_2(x)} = \log\_2(\log\_2(x))^2\$ has three solutions. Two real numbers around 1 and 5 and a very large integer solution. So what is that large integer solution?
simple transformations on both sides yield
$$
\log\_2(x)^{\frac 1 4} = \log\_2(\log\_2(x)) \\
2^{2^{log2(x)^{1/4}}} = x
$$
Now, lets substitute \$y=log2(x)^{1/4}\$. Note that \$y\$ has to be an integer as well. This yields two equations:
$$
2^{2^y} = x, \quad y=\log\_2(x)^{\frac 1 4} \\
2^{2^y} = x, \quad y^4=\log\_2(x) \\
2^{2^y} = x, \quad 2^{y^4}=x \\
2^{2^y} = 2^{y^4} \\
2^y = y^4 \\
$$
The only integer solution to this is \$y=16\$, leaving us with \$x=2^{16^4}=2^{2^{2^{2^2}}}\$. The first integer that satisfies the inequality is \$x+1\$.
[Answer]
# [R](https://www.r-project.org/) + gmp, 25 bytes
```
gmp::as.bigz(2)^2^2^2^2+T
```
[Try it at RDRR!](https://rdrr.io/snippets/embed/?code=gmp%3A%3Aas.bigz(2)%5E2%5E2%5E2%5E2%2BT)
Port of [@ovs’ Python answer](https://codegolf.stackexchange.com/a/267396/42248), so be sure to upvote that one too! R has no native bigint support so this needs the gmp package.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal/tree/version-2), 29 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 3.625 bytes
```
k₴E›
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2&c=1#WyI9IiwiIiwia+KCtEXigLoiLCIiLCIiXQ==)
Bitstring:
```
10000100001000010110011010000
```
Port of the python answer, but without any digits at all.
## Explained
```
k₴E›­⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏⁠‎⁡⁠⁣‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏‏​⁡⁠⁡‌­
k‚Ç¥E # ‚Äé‚Å°2 ** 65536
› # ‎⁢+ 1
üíé
```
Created with the help of [Luminespire](https://vyxal.github.io/Luminespire).
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 21 bytes
*-1 thanks to [@l4m2](https://codegolf.stackexchange.com/users/76323/l4m2)*
The only (decimal) digit used in the source is `0`.
```
_=>-~(-~0n>>~0xFFFFn)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1k63TkO3ziDPzq7OoMINCPI0/yfn5xXn56Tq5eSna6RpaGr@BwA "JavaScript (Node.js) – Try It Online")
This computes \$1+2^{1+65535}\$
---
With all the BigInt suffixes and extra parentheses due to a different operator precedence, a direct port of [ovs' answer](https://codegolf.stackexchange.com/a/267396/58563) would be **25 bytes**:
```
_=>-~(2n**2n**2n**2n**2n)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1k63TsMoT0sLFWv@T87PK87PSdXLyU/XSNPQ1PwPAA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Wolfram Language(Mathematica)](https://www.wolfram.com/wolframscript/), 13 bytes
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/98oDgq1jfSN/v//r1tQlJlXAgA)
```
2^2^2^2^2+2/2
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
Ｉ⊕Ｘ²Ｘ⁴¦⁸
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwzMvuSg1NzWvJDVFIyC/PLVIw0hHAcIw0VGw0AQB6////@uW5QAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
² Literal integer `2`
Ｘ Raised to power
‚Å¥ Literal integer `4`
Ｘ Raised to power
⁸ Literal integer `8`
‚äï Incremented
Ｉ Cast to string
Implicitly print
```
10 bytes using only one superscript digit:
```
Ｉ⊕Ｘ²Ｘ⊗²⊗⊗²
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM5sbhEwzMvuSg1NzWvJDVFIyC/PLVIw0hHAcJwyS9NygEKG2nqKMDYCDEIsP7//79uWQ4A "Charcoal – Try It Online") Link is to verbose version of code. Explanation: As above, but uses `Doubled` (`⊗`) to make `4` and `8` from `2`. (A port of @ovs' Python solution would have been 12 bytes.)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
⁹²2*‘
```
[Try it online!](https://tio.run/##y0rNyan8//9R485Dm4y0HjXM@P8fAA "Jelly – Try It Online")
Port of [@ovs’ Python answer](https://codegolf.stackexchange.com/a/267396/42248), so be sure to upvote that one too! The superscript digits are permitted as per reply to comment from @Simd (the OP).
## Explanation
```
‚Åπ | 256
² | Squared
2* | 2 to the power of this
‘ | +1
```
[Answer]
# [Haskell](https://www.haskell.org/), 14 bytes
```
succ$2^2^2^2^2
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzv7g0OVnFKA4K/@cmZuYp2CoUFGXmlSik/f@XnJaTmF78Xze5oAAA "Haskell – Try It Online")
Port of @ovs [python answer](https://codegolf.stackexchange.com/a/267396/84844)
[Answer]
# [Nekomata](https://github.com/AlephAlpha/Nekomata), 5 bytes
```
¥:*Ë→
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70iLzU7PzexJHHBgqWlJWm6FisPLbXSOtz9qG3SkuKk5GKoKEwWAA)
```
¥:*Ë→
¥ Push 256
: Duplicate
* Multiply
Ë Power of 2
‚Üí Increment
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 12
```
2dddd^^^^z+p
```
[Try it online!](https://tio.run/##S0n@/98oBQjigKBKu@D/fwA "dc – Try It Online")
[Answer]
# [Alice](https://github.com/m-ender/alice), 14 bytes
[Try it online!](https://tio.run/##S8zJTE79/99I/f3@/RmuGfoK/goOXP//AwA "Alice – Try It Online")
The trailing new line is required
I'm using a screenshot as the non ascii character gets removed on save
Port of [lyxal](https://codegolf.stackexchange.com/users/78850/lyxal)'s [solution](https://codegolf.stackexchange.com/a/267397/97729)
Explanation:
```
2 Pushes 2 on the stack
'0xFFFF Pushes 65535 on the stack
h Increment the top of the stack
E Pop y, pop x, push x^y
h Increment the top of the stack
/ O @ Output and exit
```
Same byte count using `Ā` for \$256 \* 256 = 65536\$
```
2'Ā.*Eh/ O @
```
[Try it online!](https://tio.run/##S8zJTE79/99I/UiDnpZrhr6Cv4ID1///AA "Alice – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
‚ÇÅno>
```
[Try it online.](https://tio.run/##yy9OTMpM/f//UVNjXr7d//8A)
Without using the superscript number(s) either, it's still 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage):
```
žHo>
```
[Try it online.](https://tio.run/##yy9OTMpM/f//6D6PfLv//wE)
**Explanation:**
```
‚ÇÅ # Push builtin 256
n # Square it to 65536
žH # (or alternatively) Push builtin 65536
o # Pop and push 2 to the power this 65536
> # Increase it by 1
# (which is output implicitly as result)
```
[Answer]
# [J](https://www.jsoftware.com), 9 bytes
```
>:^^:*~2x
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70wa8FOJT0F9TQFWysFdR0FAwUrINbVU3AO8nFbWlqSpmux0s4qLs5Kq86oAsK_Ga3JlQ5SbmdlVBGnZaWcqMeVAeHH6RvZ6WUChbkS84pBQobaQCVmpqbGZlypyRn5CkBrFIBSEE46MicDwoFYsWABhAYA)
```
>:^^:*~2x
2x bigint 2
^^:*~ call ^^:* with 2x on both sides:
^: repeat
^ 2^ (2 is the left argument of ^:)
* 2*2 times (the 2s are the left and right arguments of ^:)
the result so far = 2^(2^(2^(2^(2))))
>: increment
```
Bonus 10 and 11 bytes:
```
>:2x^*:#a.
a. a built-in string containing 256 extended ascii chars
# length of it (256)
*: square
2x^ raise 2 to the power of that
>: increment
>:^/2>.i:2x
i:2x -2 -1 0 1 2
2>. apply max(2, x) to each element; 2 2 2 2 2
^/ reduce by ^ from the right; 2^(2^(2^(2^(2))))
>: increment
```
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 32 bytes
[Try it online!](https://tio.run/##K8gvTy0qzkjNydFNzi9K/f8/OikzPTOvJNbKqiC/XMNQ21DHUFv9/f796tGKhrGa2ob//wMA "PowerShell Core – Try It Online")
Explanation:
```
1+0xFFFF[!1] # Calculates 65536
[bigint]::pow(1+1, ) # Calculates 2^65536
+1 # Increments by 1 and implicitly prints on stdout
```
[Answer]
# [sclin](https://github.com/molarmanful/sclin), 18 bytes
```
1 1+""S>c1+ ^1+
```
[Try it on scline!](https://scline.fly.dev/##H4sIAEZCd2UCAzNUMNRWer9_v1KwXbKhtkKcoTYAtxgMTBIAAAA#)
Didn't read the question closely x\_x.
] |
[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/80696/edit).
Closed 7 years ago.
[Improve this question](/posts/80696/edit)
## Write one/two program(s)/function(s):
1. The first one should return a truthy value if given your Stack Exchange username.
### ~~Optional~~
2. An obfuscated one (as explained below) that does the same thing.
### Rules for number 2:
1. May be no more than ten times the byte-count of number 1 or 100 bytes, whichever is higher.
2. Must be written in the same language as number 1.
# Test cases
(for my case:)
```
input output
-------------------
Seims true
BestCoderXX false
```
### Winning
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest byte count for number one wins.
[Answer]
# JavaScript
```
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(![]+[])[+[]]+(!![]+[])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()(+[]+[+[]]+(+[![]])+![])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(![]+[])[+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(![]+[])[!![]+!![]+!![]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+!![]])()+[])[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(+!![]+[+!![]]+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+[])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(+!![])+(!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(!![]+!![])+(+[])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(+!![])+(+[])+(+[])+![]+(+!![])+(+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(+[])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+[])+(!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+[])+(!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]))[(![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[+[]]](![])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]])())()
```
To run:
Open the console (`Ctrl + Shift + I`)
Type `f =`
Paste the above
To use:
`f('the string you want to test')`
## EDIT: fixed ES6 version below
```
[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]+(+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(![]+[])[+[]]+(!![]+[])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([]+(+[])[([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]])()(+[]+[+[]]+(+[![]])+![])[+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(![]+[])[+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(![]+[])[!![]+!![]+!![]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+!![]])()+[])[+!![]+[+!![]]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([![]]+[][[]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[!![]+!![]+!![]]]+(+!![]+[+!![]]+(!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+![]+(+!![])+(+[])+(+[])+![]+(+!![])+(+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(+[])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(+!![])+(!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![])+![]+(+!![])+(+[])+(+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![]+!![])+(+[])+![]+(!![]+!![]+!![]+!![]+!![])+(!![]+!![])+![]+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(!![]+!![]+!![]+!![])+(+!![])+![]+(!![]+!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+![]+(+!![])+(+[])+(+!![]))[(![]+[])[!![]+!![]+!![]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]][([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+(![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[+!![]+[+[]]]+(![]+[])[+!![]])()([][[]]))[+!![]+[+[]]]+(![]+[])[!![]+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[+[]]](![])+(+[]+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!![]+[+[]]]+(![]+[])[!![]+!![]]+(![]+[])[!![]+!![]]])[!![]+!![]+[+[]]])())()
```
Note: This checks equality with the username of whoever runs it, not my username
[Answer]
# Python 2 (Non-Competing)
*This was posted before the rules were changed significantly.*
```
False = True; True = False; True = True; print (`'Riker'.lower().upper()`=="Riker" and "Riker" == `raw_input()`) <> True and raw_input()=="Riker"
```
[Answer]
# Javascript
```
eval(function(B,á,l,i,n,t){if(n=function(B){return B},!"".replace(/^/,String)){for(;l--;)t[l]=i[l]||l;i=[function(B){return t[B]}],n=function(){return"\\w+"},l=1}for(;l--;)i[l]&&(B=B.replace(new RegExp("\\b"+n(l)+"\\b","g"),i[l]));return B}('3 4(0){2(!(0=="9á5")){{1 7}}6{{1 8}}}',10,10,"notMyName|return|if|function|HELLO_WORLD|lint|else|false|true|B".split("|"),0,{}));
```
I first created a half-readable code, then I ran it trough RegPack, then an obfuscator, then a minifier, then RegPack again, and lastly a different minifier.
Note: RegPack is worse than an obfuscator
Made a slight modification on variable names after @LeakyNun pointed out something
[Answer]
# Python 2 (Non-Competing)
*This was posted before the rules were changed significantly.*
```
print raw_input()=="Eᴀsᴛᴇʀʟʏ Iʀᴋ"
```
Quite obfuscated to non-programmers or people who only code in brainfuck.
@Downvoters: Also serves to point out the definition of "obfuscated" needs to be fixed.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth)
```
q1409257787840474805614C
```
[Test suite.](http://pyth.herokuapp.com/?code=q1409257787840474805614C&test_suite=1&test_suite_input=%22Leaky+Nun%22%0A%22Nyan+Luke%22&debug=0)
Encodes the input string in base-256, and then check if it is equal to `1409257787840474805614`.
[Answer]
## 05AB1E
```
žnžo‡"Vnrtmz"Q
```
Uses the Atbash cipher.
[Try it online](http://05ab1e.tryitonline.net/#code=xb5uxb5v4oChIlZucnRteiJR&input=RW1pZ25h)
[Answer]
# Java
```
public boolean eval( String username )
{
int s = 2304854;
int w = 1660790;
String r = "";
int l = username.length();
int b = 0;
Random ra = new Random( s );
boolean sw = false;
for ( int i = 0; i < l; i++ )
{
if ( !sw && i > 5 )
{
sw = true;
ra = new Random( w );
}
int ran = ra.nextInt( 25 ) + 97;
b |= ( ( i == 5 ? ' ' : ran - ( ( i == 0 || i == 6 ) ? 32 : 0 ) == username.getBytes()[ i ] ? 1 : 0 ) << i );
}
return b == 2015 && l == 10;
}
```
# None- Golfed
```
public boolean isShaunWild(String name){
return name.equals("Shaun Wild");
}
```
Just a bit of fun haha. Horribly unreadable and hard to understand what it is without reading through it a couple of million times :)
[Answer]
# Oracle SQL 11.2
Returns 0 if true, 1 if false
```
SELECT SIGN(ABS(TRUNC(SUM(ASCII(SUBSTR(:1,LEVEL,1))*POWER(10,LEVEL*(LENGTH(:1)-1.14265533)))/CEIL(AVG(LEVEL))-
CEIL(AVG(POWER(ASCII(SUBSTR(:1,LEVEL,1)),6.42)))+76158.880743588573892)))
FROM DUAL CONNECT BY LEVEL<=LENGTH(:1)
```
[Answer]
## Perl 5
```
eval eval '"'.('`'|'%').('['^'-').('`'|'!').('`'|',').('{'^'[').('['^'.').('`'|'.').('['^'+').('`'|'!').('`'|'#').('`'|'+').('{'^'[').('['^'.').'='.'>'.('['^'*').'\\'.'{'.'_'.(';'&'=').('^'^('`'|')')).(';'&'=').('`'^'!').';'.'\\'.'"'.'!'.('{'^'.').';'.('`'^"'").'!'.('`'^'!').(':'&'=').('{'^'-').('`'^',').('`'^'"').('^'^('`'|')'))."'".'\\'.'@'.('{'^',').'-'.('^'^('`'|',')).'('.('`'^',').'('.('`'^'%').('{'^'*').('{'^'#').'-'.('^'^('`'|'*')).(';'&'=').'<'.'>'.'#'.'('.('{'^'"').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'*')).'-'.'<'.'>'.'#'.('^'^('`'|'+')).'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'.')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'#').'-'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'(').('`'^'%').'<'.'>'.'#'.','.('{'^',').'_'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.'%'.('{'^'*').('{'^'#').'-'.'#'.')'.'<'.'>'.'#'.','.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('{'^'.').('{'^'*').('{'^'#').'-'.'#'.'!'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').('^'^('`'|'+')).'<'.'>'.'#'.('^'^('`'|'*')).('{'^'*').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'.'.'%'.('{'^'*').('{'^'#').','.('`'^'$').('^'^('`'|'/')).'<'.'>'.'#'.('^'^('`'|'.')).('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'/').'-'.'<'.'>'.'#'.'-'.'%'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'_'.','.('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').'-'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'-'.('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').'='.'<'.'>'.'#'.('^'^('`'|'.')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'-'.('`'^'%').('{'^'*').('{'^'#').','.('{'^'(').('`'^'!').'<'.'>'.'#'.('^'^('`'|'*')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('`'^'!').'<'.'>'.'#'.')'.'#'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').'%'.'<'.'>'.'#'.'-'.'#'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').'_'.','.('`'^'#').'-'.'<'.'>'.'#'.','.('{'^'/').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.'%'.('{'^'*').('{'^'#').','.('{'^'(').'='.'<'.'>'.'#'.'('.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).(';'&'=').'<'.'>'.'#'.')'.'%'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'%'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').'-'.'#'.'-'.'<'.'>'.'#'.')'.'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'+')).'<'.'_'.'>'.'#'.'('.('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'.'.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'%'.'<'.'>'.'#'.','.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('{'^'.').('{'^'*').('{'^'#').'-'.'#'.'!'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').'-'.'#'.('^'^('`'|'+')).'<'.'>'.'#'.('^'^('`'|'*')).('{'^'*').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'.'.'%'.('{'^'*').('{'^'#').','.('`'^'$').('^'^('`'|'/')).'<'.'>'.'#'.('^'^('`'|'.')).('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').','.'%'.('{'^'*').('{'^'#').'-'.'#'.')'.'<'.'>'.'#'.')'.'!'.'_'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').','.('{'^'.').('{'^'*').('{'^'#').'-'.('^'^('`'|'*')).'-'.'<'.'>'.'#'.('^'^('`'|'.')).('{'^')').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'-'.('{'^'.').('{'^'*').('{'^'#').','.('`'^'#').'='.'<'.'>'.'#'.('^'^('`'|'.')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'$').('^'^('`'|'/')).'<'.'>'.'#'.'('.('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('`'^'!').'<'.'>'.'#'.('^'^('`'|'.')).('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'-'.'<'.'>'.'#'.'('.('{'^'"').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'_'.('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'+')).'<'.'>'.'#'.'('.('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('^'^('`'|'+')).'<'.'>'.'#'.','.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').'-'.('{'^'.').('{'^'*').('{'^'#').'-'.'#'.'!'.'<'.'>'.'#'.('^'^('`'|'*')).('{'^'-').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').','.('{'^'(').')'.'<'.'>'.'#'.'('.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').('^'^('`'|'.')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'#').('`'^'!').'<'.'>'.'#'.('^'^('`'|'.')).('{'^'.').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').'_'.'-'.('^'^('`'|'-')).('`'^'!').'<'.'>'.'#'.')'.'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^')').','.('{'^'.').('{'^'*').('{'^'#').','.('{'^'(').('`'^'%').'<'.'>'.'#'.'-'.'#'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('`'^'#').'-'.'<'.'>'.'#'.','.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').','.('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'(').'='.'<'.'>'.'#'.'('.('{'^',').('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).(';'&'=').'<'.'>'.'#'.','.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'.').'-'.('^'^('`'|'+')).('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'%'.'<'.'_'.'>'.'#'.('^'^('`'|'*')).('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^')').('^'^('`'|'/')).'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).'-'.'<'.'>'.'#'.')'.'\\'.'$'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'+')).'<'.'>'.'#'.'('.('{'^'(').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').'.'.'%'.('{'^'*').('{'^'#').'-'.('^'^('`'|'-')).('^'^('`'|'+')).'<'.'>'.'#'.'('.('{'^'#').('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').','.('{'^'.').('{'^'*').('{'^'#').'-'.'\\'.'$'.('^'^('`'|'/')).'<'.'>'.'#'.('^'^('`'|'*')).('{'^'+').('^'^('`'|')'))."'".'\\'.'@'.('{'^'(').('^'^('`'|'.')).('{'^'.').('{'^'*').('{'^'#').'-'.'#'.(';'&'=').'<'.'>'.'#'.('^'^('`'|'.')).('{'^'.').')'.('^'^('`'|')'))."'".'\\'.'@'.('{'^'/').('^'^('`'|'/')).('^'^('`'|'+')).('{'^'*').('{'^'#').','.('{'^'/').('^'^('`'|'.')).('`'^'"').'\\'.'}'.('!'^'+').'"'
```
Original code was a one liner, now... it's technically still a one liner.
[Try it here!](https://ideone.com/qrbWzO)
[Answer]
## JavaScript (ES6)
```
(s)=>/(.)(.)(.)(.)(.)(.)(.)\3[^\1]{6}\2[^\2]{5}\5[^\3]{6}\4[^\4]{5}\6[^\5]{7}\7[^\6]{10}\1[^\7]+/.test(s+atob("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo="))
```
[Answer]
# JavaScript ES6
My answer assumes an only-ASCII encoding. This, I am sure, is the optimal solution for JavaScript ES6 in such a setting--this is the only encoding I wish to cover. If anyone wishes to tackle non-ASCII JS, be my guest ;) This clocks in at 61 bytes, leaving me 610 bytes to obfuscate.
```
n=>n=="C\u1d0f\u0274\u1d0f\u0280 O'B\u0280\u026a\u1d07\u0274"
```
Here is my obfuscated version, clocking in 588 bytes, less than 610.
```
(c,f,d,W=this,k=e=>+(`0x`+e),C=(O,...m)=>new(O[w=`constructor`]!=C[w]?O[w]:O)(...m))=>(($,_)=>$<=_&&_<=$)([g=W[(-~(Math.sqrt((P=parseInt)(P,b=31))+P(NaN,b+=5))+0xec)[D=`toString`](b)],t=n=>(j=n=>W[n[D](b)])(n),E=W[505019[D](b)]([...[1663483,552948,1629769,516801].map(e=>e[D](b)).join``].map((s,i)=>+(42742[D](2)[i])?s.toUpperCase():s).join``),A=n=>(p,c)=>p+n+c,...[for(x of c)x.charCodeAt()]].slice(-c.length),g(`[${[...`1${[...`mn0nkjp0mio0nkjp0mkg0ji0np0jp0mm0mkg0mho0nkjh0mio`].reduce(A(-~[]))}`.match(/../g).map(e=>""[w][E](P(e,b)-4)).reduce(a)].reduce((p,c)=>c<"!"?`${p},`:p+c)}]`))
```
## Bonus material
This was my original, 947-byte obfuscation for the original challenge:
```
(c,d,f,M=Math,W=Z=this,q=($,_)=>$<=_&&_<=$,k=e=>+[`${+[+[]][+[]]}x`+e][+[]],
C=(O,...m)=>new(O[w=`constructor`]!=C[w]?O[w]:O)(...m))=>q([[d=[f=[~c]]+f],g
=W[(-~(M.sqrt(parseInt(P=parseInt,b=~-[[_=+!+[]<<-~![]][+[]]<<[_<<_/_][+[]]]
))+P(NaN,b+=5))+(e=>+[`${+[+[]][+[]]}x`+e][+[]])(C([],...C(Set,[..."abced"].
map(j=>j+i+(u+=[[u,u]],(i=j>i?j:i)?i:[]),i=u=[])[M.atan2(u[l="length"],~[]<<
~[])>>[]])).reduce(a=(p,c)=>p+c,[]+[]))|+[])[D=`toString`](b)],t=n=>(j=n=>W[
n[D](b)])(n),E=t(h=505019)([...[1663483,552948,1629769,h+=11782].map(e=>e[D]
(b)).reduce(a)].map((s,i)=>+[42742[D](2)][+[]][i]?s.toUpperCase():s).reduce(
a)),A=n=>(p,c)=>p+n+c,...[for(x of c)x[`c${E.slice(-7)}${[[]+[]][+[]][w][E](
P(42/_,_<<_<<_))+`${[]+[]}t`}`]()]].slice(-c[l]),g(`[${[...`1${[...`mn0nkjp`
+`0mio0nkjp0mkg0ji0np0jp0mm0mkg0mho0nkjh0mio`].reduce(A(-~[]))}`.match(/../g
).map(e=>[[]+[]][+[]][w][E](P(e,b)-4)).reduce(a)].reduce((p,c)=>c<"!"?`${p},
`:p+c)}]`))
```
[Answer]
# C++11
Golfed (129 characters including whitespaces):
```
#include<iostream>
#include<string>
int main(){std::string s;std::cin>>s;std::cout<<(s.compare("dorukayhan")==0?"true":"false");}
```
Obfuscated (much less than 1290 characters):
```
#define import using namespace
#include<iostream>
#include<string>
#define def int
import std ;
def main() {
string s ;
cin >> s ;
char c[] = {100, 111, 114, 117, 107, 97, 121, 104, 97, 110, 0} ;
cout << (s.compare(c) == 0 ? "true" : "false") ;}
```
] |
[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/2041/edit).
Closed 3 years ago.
[Improve this question](/posts/2041/edit)
For 2 arrays each with X elements, what is the SHORTEST code to subtract every element in the second from every element in the first, 1 to 1
so, for example:
A1 = [10,11,12]
A2 = [1,2,3]
A1 "-" A2 should == [9,9,9]
[Answer]
## R, 3 chars
(following Chris' counting method that includes the variable names in the count)
```
a-b
```
`a` and `b` can be defined as follows:
```
a <- c(10,11,12)
b <- c(1,2,3)
```
(`c` is the array construction function in R)
[Answer]
# J, 1 char
I will answer too because finally I don't have to use 2 bytes worth of enclosing brackets for J. :)
```
-
10 11 12 - 1 2 3
9 9 9
```
[Answer]
## Scheme, 11 chars
Assume the lists are named `a` and `b`:
```
(map - a b)
```
Example:
```
(map - '(10 11 12) '(1 2 3)) ; => (9 9 9)
```
[Answer]
## In Haskell (10):
```
zipWith(-)
```
will do the job. Please note, that the lists will be truncated, if their length isn't equal.
[Answer]
```
>>> class L(list):
... def __sub__(self, other):
... return map(int.__sub__,self, other)
...
>>> a=L([10,11,12])
>>> b=L([1,2,3])
>>> a-b
[9, 9, 9]
>>>
```
[Answer]
# ES6, 20
```
a.map((x,i)=>x-b[i])
```
[Answer]
### In Python (24):
```
map(lambda a,b:a-b,a,b)
```
### Smaller (21):
```
map(int.__sub__,a,b)
```
[Answer]
Groovy:
```
List a = [1,2,3]
List b=[2,7,9]
[0,1,2].each { println(a[it]-b[it]) }
```
[Answer]
### Scala, 51 chars
```
Array(10,11,12) zip Array(1,2,3)map(x=>x._1-x._2)
```
(but includes initialisation, Array-Declaration)
```
(10 to 12).zip (1 to 3)map(x=>x._1-x._2)
```
is a bit shorter, but produces an Vector.
```
a zip b.map(x=>x._1-x._2)
```
is even shorter, but of course I could do
```
a zip b.map f
```
then. Or just
```
g
```
[Answer]
# CJam, 10 bytes
CJam is newer than this challenge, but I thought it's funny how uncompetitive it is for once:
```
l~]z{~-}%p
```
This is an STDIN to STDOUT program, reading input like `[10 9 8] [1 2 3]`. I know everyone else is answering in snippets, but that wouldn't really be shorter here, because you'd have to replace `]` by something like `a\a\+`.
[Answer]
# TI-BASIC, 5 bytes
```
L1-L2
```
Input lists are stored in the `L1` and `L2` tokens. (TI-BASIC doesn't have STDIN or equivalent.)
Answer is stored in `Ans`.
**Example:**
```
{10,11,12→L1
{10 11 12}
{1,2,3→L2
{1 2 3}
L1-L2
{9 9 9}
```
[Answer]
Not counting `USE: syntax math sequences ; !` because it's not needed (on the REPL).
Factor: `[ - ] 2map`
[Answer]
Not the shortest, but this is what I came up with in javascript...
```
t=0;
ar=[];
for(i=0;i<ar.length;i++){
t=a[i]-b[i];
ar.push(temp);
};
```
**Input:** a = [10,11,12], b = [1,2,3]
**Output:** [9,9,9]
[Answer]
# [8th](http://8th-dev.com/), 10 bytes
**Code**
```
' n:- a:op
```
**Explanation**
`a:op` takes two arrays and invokes the word `n:-` to the corresponding elements of "a1" and "a2", producing a new array "a3".
**Example**
```
ok> [10,11,12] [1,2,3] ' n:- a:op .
[9,9,9]
```
[Answer]
# Java 8, 45 bytes
```
a->b->{for(int i=0;i<a.length;a[i]-=b[i++]);}
```
Modifies the first input-array instead of returning a new one to save bytes.
**Explanation:**
[Try it here.](https://tio.run/##bY@xboNADIb3PIVHUOAU0pEEqarUrVNGxGAul9T0uDtxJhVCPDu9AFI7VPJgWZ/9f27wgal1yjTXr1lq9B4@kMy4A/CMTBKaQIieSYtbbySTNeJ9a05kuKyS/5A3a3zfqm5FigIknGHGtKjTYrzZLgpzoPMhpxMKrcydP3MsqUrPdUn7fRXn05wHiVCur3Xw2HQelq7QBsXowh2Ze1kBxk9dgCUKsOtwCGFGfa@TMTskWZZkxylfMCnQOT1ECxgLlFI5jv7gyTF5meIVvgyeVStsz8KFONYm@v329XnBC7arynZx2Zx20/wD)
```
a->b->{ // Method with two integer-array parameters and no return-type
for(int i=0; // Start at index 0
i<a.length; // Loop over the input arrays by index
a[i]-=b[i++] // Modify array `a` by subtracting the values of `b` on the same index
); // End of loop
} // End of method
```
[Answer]
# Java 8, 29 bytes
I got creative with I/O types for this. It's a lambda (curried) from an ordered `IntStream` (A1) to a lambda from a mutable `List<Integer>` (implementing `remove(int)`, e.g. `ArrayList`) (A2) to `IntStream`. Assign to `Function<IntStream, Function<List<Integer>, IntStream>>`.
```
s->l->s.map(n->n-l.remove(0))
```
[Try It Online](https://tio.run/##jZFLa8MwEITPya/YowS2aJse0jwMpVAotOSQ3koPiqMEubJktGuXEPzbXdlxyYtCbws7841mlclKxq5QNlt/NUW5MjqF1EhEeJPawn44KLyuJClAkhSWWTCIkrQRm9KmpJ0Vz/0wO@6QvJK5eLG07Kbon75XjTQLLrVVPjk1XQKTBLBckZcpwbzBODFxgiKXBbNxYmMjvMpdpdgN581gOgw1Dt36FpXTa8hDQxZw2m4/PkH6LfK28ODvVECYnzzq0Xu5w17FrPoGbSmg9qMIxhGM7iN4qPn0DHnWEEzgtb4L5pmIXQVKbAVdYC9qQ28jiO8iCKHjmnepyx2SyoUrSYRftGQs@z2akEVhdgx5PxjeHu/dLVYZ65mTSSVNqRYbLlJnjEqJXV3m6bBwHgW57lG8i66HdfMD)
Yeah, that's right; I'm using stateful lambdas. I could lose 4 byes by taking A2 as a `Stack` and using `pop`, but I'm hesitant to stray that far from the `List` interface.
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), 3 [bytes](https://github.com/mudkip201/pyt/wiki/Codepage)
```
←←-
```
Takes arrays as input; alternatively, if the arrays are already on the stack, with the second one on the top, it's one character:
```
-
```
Explanation:
```
← Get first array
← Get second array
- Get elementwise difference (as an array)
```
[Try it online!](https://tio.run/##K6gs@f//UdsEINL9/9/Q1BgA)
[Answer]
# [Funky](https://github.com/TehFlaminTaco/Funky), 27 bytes
```
a=>b=>a::map((n i)=>n-b[i])
```
[Try it online!](https://tio.run/##JY2xDoIwFAB3vuKFOLQGDcWNpJ1cXFxkIyQ8kcoTeRAoUWL8dmxicnfr2ZnbZbV6RW2u2mCadjgIwUBSG95dcyrkuoGsoQk8j3lygGCRqwVeuEBvwWFLfAfX1EA8zA7s2HdwyY6nc0Ca@v1Y4y3cYpim0/AkVwbl/8La1O@6Kj85F99SBsNI7IQVlMeF9FWFlKuKI1DKmwS@SQSHHw "Funky – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
_
```
[Try it online!](https://tio.run/##y0rNyan8/z/@////0YYGOgqGhkBsFAvk6CgY6SgYxwIA "Jelly – Try It Online")
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 7 bytes
```
L*,BcB_
```
[Try it online!](https://tio.run/##S0xJKSj4/99HS8cp2Sn@v4tOWmZRcYlCYlFRYqWOgpaVjqGBgqGhgqERl4tOcWpyfl4KVA4kpWCkYMylgqSDK4xLBVkVl0pOYm5SSqKCoZ27XQWX/38A "Add++ – Try It Online")
Auto vectorisation is so boring.
[Answer]
# [Zsh](https://www.zsh.org/), 27 bytes
That's right, you can zip arrays in your shell scripts!
**Input**: arrays `a` and `b`
**Output**: stdout
```
for x y (${a:^b}) <<<$[x-y]
```
[Try it online!](https://tio.run/##HcjdCoIwGMbx8/cqHmTw5sFgW5/WvJIomLhQEAWN0mLXvpbP0e/5f6Ymvpu28xi9q9G1vb@gHsi/XIfJPyElMvHPGblyI76lDjlVq0zI42MYMWNB@u58r0IOa624znK5xSQu1zHVQ@8j73HAEScUDNbYYQsDzcRFkkxUqRsFDQXFRD8 "Zsh – Try It Online") (It takes more code to read stdin into arrays than it does to pairwise subtract!)
If the output must be another array, either **27** or **29** bytes.
```
for x y (${a:^b}) c+=$[x-y] # if c was declared as an array
for x y (${a:^b}) c+=($[x-y]) # if c was not declared
```
[Answer]
# SmileBASIC, 13 bytes
```
ARYOP 1,A,A,B
```
Inputs: `A`, `B`
Output: `A`
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 3 bytes
```
í-V
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=7S1W&input=WzEwLDExLDEyXQpbMSwyLDNd)
```
í-V :Implicit input of arrays U & V
í V :Interleave both
- :Reduce each pair by subtraction
```
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
**General programming questions** are off-topic here, but can be asked on [Stack Overflow](http://stackoverflow.com/about).
Closed 9 years ago.
[Improve this question](/posts/28113/edit)
The problem is to create a string of the same character repeated 100 times.
One potential solution in JavaScript is:
```
var i = 100,
s = '';
while(i--) s += "Z";
```
Shortest code wins.
[Answer]
## golflua: ~~109~~ 15
```
w(S.t("a",100))
```
Which is more-or-less equivalent to [Heiko's Lua answer](https://codegolf.stackexchange.com/a/28125/11376)
[Answer]
# Python2.7 - 7 bytes
```
'a'*100
```
String manipulation using `*` pretty simple.
[Answer]
# Lua, 24 bytes
This variant is based on Geobits' [comment](https://codegolf.stackexchange.com/questions/28113/code-golf-create-a-string-of-100-of-the-same-character/28125?noredirect=1#comment60670_28125):
```
print(("").rep("a",100))
```
---
## Older version, 38 bytes
```
a=""for i=0,99 do a=a.."a"end print(a)
```
**Ungolfed:**
```
a = "" -- start with empty string
for i = 0, 99, 1 do -- 100 times
a = a .. "a" -- append "a" to variable a
end
print(a) -- print result
```
[Answer]
# GolfScript, 4 characters:
```
100*
```
The input should be on the stack. This program assumes a single-character input.
[Test online](http://golfscript.apphb.com/?c=OydhJwoKMTAwKg%3D%3D).
If the character needs to be hardcoded, it's **7 characters**:
```
'a'100*
```
If the character is a newline and it needs to be hardcoded, **5 characters** (thanks to Jan Dvorak):
```
100n*
```
[Answer]
# QBasic : 22
```
PRINT STRING$(100,"A")
```
Why not?
[Answer]
# JavaScript - 20 chars
At least, shorter than Bash ;)
```
Array(101).join("a")
```
An array of length `100` joined with letter `a`.
# Perl - 12 chars
First Perl golf !
```
print"a"x100
```
Thanks to ace for shortening one character.
[Answer]
# J (7)
Very similar to the Python one
```
100$'a'
```
`100$'ab'` would output 50 times `ab`, for 100 characters total.
[Answer]
# Bash+tr, 20 bytes
```
$ printf %100s|tr \ Z
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ$
```
---
# Pure Bash, 31 bytes
```
$ printf -vs %100s;echo ${s// /Z}
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
$
```
Pretty standard stuff.
---
[Answer]
## Perl, 7 bytes
```
"a"x100
```
Almost completely the same as the Python one.
[Answer]
# Brainfuck, 27 characters (or ~~26~~ 25)
```
,>++++++++++[<..........>-]
```
This program requires input, because hardcoding a character is not possible in Brainfuck.
If it is allowed to always output 100 times the NUL character, there is a 25 char solution (thanks to Quincunx):
```
++++++++++[>..........<-]
```
[Answer]
# Haskell
```
replicate 100 'a'
```
GHCi output:
```
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
```
Code for GHC:
```
main = print $ replicate 100 'a'
```
] |
[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/75200/edit).
Closed 7 years ago.
[Improve this question](/posts/75200/edit)
Your task is to print a number. Simple, right? It is simple, but not as simple as this. The first answer is to print the number 1, the second answer is to print the number 2, etc.
## Rules
1. The first answer must print 1, and the `n`th answer must print `n`.
2. The first answer may be of any length.
3. Whitespace, comments, etc. are permitted.
4. The next answer's submission's length must within 1 unit of the previous answer's length. That is, if a submissions length is `L`, the next submission must be of length `L + 1` or `L - 1`. The length is measured in characters, not bytes.
5. No language may be used more than once.
6. No person may answer earlier than eight hours after their most recent answer.
7. No person may answer twice in a row.
8. You may not use a REPL environment.
To win, you must have the most valid answers to this question. You may use a language updated after/ made later than this challenge so long as the language was not intended to answer this challenge.
## Answer template
All answers must conform to this template.
```
# Answer N, Lang name, M characters
program
optional description
```
## Leader board
A leader board will be maintained here in this section. (If anyone wants to create a leader board counting the number of submissions a person has, I will give them a 50 rep bounty on any answer to this question.)
[Answer]
# Answer 8, [Carrot](http://kritixilithos.github.io/Carrot/), 3 bytes
```
8^
```
Note the trailing space.
[Answer]
# Answer 2, GolfScript, 1 character
```
2
```
Pushes the number 2 to the stack.
[Answer]
# Answer 5, dc, 2 characters
```
5p
```
Pushes `5` and `p`rints it.
[Answer]
## Answer 4, CJam, 3 characters
```
2))
```
Pushes 2 and increments twice.
Other solutions:
```
C4/
D5%
T3+
```
[Answer]
# Answer 6, pl, 3 characters
```
6⌂⌂
```
The last two characters are no-ops.
[Answer]
# Answer 7, Befunge, 4 characters
```
43+.
```
Add 4 to the stack, then 3, add the top 2 stack values, then print the top value as an int.
[Answer]
## Answer 10, PowerShell, 3 chars
```
+10
```
Even when not golfing we need to golf. :) Frustratingly, though, here the `+` is superfluous, but we can't go down to 2 chars since the Fission answer was 4.
[Answer]
## Answer 12, [MSM](https://esolangs.org/wiki/MSM), 3 characters
```
.21
```
`.` concatenates the two rightmost elements `2` and `1` to `12`. MSM stops when there's only one element left.
[Answer]
# Answer 13, TI-BASIC, 2 characters
```
13
```
Pretty much.
[Answer]
## Answer 15, 05AB1E, 4 characters
```
4o<?
```
[Try it here.](http://05ab1e.tryitonline.net/#code=NG88Pw&input=)
Basically, it does 2^4 - 1.
[Answer]
# Answer 14, [Pylons](https://github.com/morganthrapp/Pylons-lang), 3 characters.
```
B4+
```
Pushes 10 and 4 to the stack and then adds them.
[Try it online](http://pylons.tryitonline.net/#code=QjQr&input=)
[Answer]
# Answer 3, Vitsy, 2 bytes
```
3N
```
Pushes three, outputs three.
[Try it online!](http://vitsy.tryitonline.net/#code=M04&input=)
For lols, verbose mode:
```
push 3;
output top as number;
```
[Answer]
# Answer 1, Retina, 0 characters
The empty program outputs the number of matches on the input. Since the empty program matches the input once, 1 is outputted.. [Try it online!](http://retina.tryitonline.net)
[Answer]
# Answer 9, [Fission](https://github.com/C0deH4cker/Fission), 4 characters
```
R'9O
```
Creates an atom moving right
Sets its mass to character value of 9
Outputs the ascii character of the mass and destroys the atom
[Try it online](http://fission.tryitonline.net/#code=Uic5Tw&input=)
[Answer]
## Answer 11, Pyth, 2 characters
```
11
```
Yawn...
[Answer]
# Answer 16, [Jelly](https://github.com/DennisMitchell/jelly/wiki), 3 characters
```
⁴OO
```
The two `O`'s was just to fill the remaining 2 characters. [Test here.](http://jelly.tryitonline.net/#code=4oG0T08&input=&args=)
] |
[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 8 years ago.
[Improve this question](/posts/20585/edit)
I thought it might be fun to throw this on here.
Generate an ASCII-art for one of your favorite videogames.
What you want to generate is up to you but it should meet 2 requirements.
1. It should be able to identify the game. So either a logo or
something familiar like the triforce in Zelda. a pokeball for
pokémon or an actual pokémon.
2. Make it solid.
I'm guessing the second requirement is a bit vague, I just dont know how to explain it so let me show you with the triforce.
```
Wrong
/\
/__\
/\ /\
/__\/__\
Right
#
###
#####
#######
# #
### ###
##### #####
####### #######
```
This is a popularity-contest, so be creative and dont worry about the length of your code.
### Rules
* No external resources
* You can use any language you like
**Edit**
You are meant to write some kind of algorithm that will create your ascii art rather than simply arranging the characters.
*Sorry for changing the question*
Happy Coding!
[Answer]
## Bash
An actual pokémon? Ok. I present the Voltorb, seen from behind.
```
#!/bin/bash
echo -e '\e[31m' # escape character for red font
s=6
for i in `seq 8 2 16`; do
if [ $i -ne 10 ]; then
for j in `seq $s`; do
echo -n ' '
done
for j in `seq $i`; do
echo -n '#'
done
echo
fi
s=`expr $s - 1`
done
echo -e -n '\e[97m' # escape character for white font
s=2
for i in `seq 16 -2 8`; do
if [ $i -ne 10 ]; then
for j in `seq $s`; do
echo -n ' '
done
for j in `seq $i`; do
echo -n '#'
done
echo
fi
s=`expr $s + 1`
done
echo -e '\e[0m' # escape character for default font color
```
Output:
[Answer]
## Javascript
**Invaders !**
```
for(j=8,o='';j--;o+='\n')for(i=11;i--;)o+=1&"ĎĘƾŭĽļĽŭƾĘĎ".charCodeAt(i)>>j?'##':' '
```
Output :
```
## ##
## ##
##############
#### ###### ####
######################
## ############## ##
## ## ## ##
#### ####
```
**Triforce**
```
for(j=8,o='';j--;o+='\n')for(i=15;i--;)o+=1&"āăćďėijűǰűijėďćăā".charCodeAt(i)>>j?'##':' '
```
Output :
```
##
######
##########
##############
## ##
###### ######
########## ##########
############## ##############
```
Any 8-lines (can be extended to 16 easily) logo can be displayed with that code, you have to change only the encoding string.
Each character of the string corresponds to a column.
You can also declare a generic function :
```
function f(s){for(j=8,o='';j--;o+='\n')for(i=s.length;i--;)o+=1&s.charCodeAt(i)>>j?'##':' ';return o}
f('ĎĘƾŭĽļĽŭƾĘĎ'); //invaders
f('āăćďėijűǰűijėďćăā'); //triforce
```
To encode the column (8bits), use `parseInt`, specify the bits with a `1` at the start to enforce unicode.
Example for the first part of the triforce :
```
String.fromCharCode(parseInt('100000001',2),parseInt('100000011',2),parseInt('100000111',2),parseInt('100001111',2),parseInt('100010111',2),parseInt('100110011',2),parseInt('101110001',2),parseInt('111110000',2))
```
Output: `"āăćďėijűǰ"`
[Answer]
## Python 2.7
```
#!/bin/python2
a,b=[[78,20],[2,20,47,28],[5,20,40,27],[0,23,37,23],[2,21,14,28],[0,24,29,32],[2,22,21,40],[4,19,20,42],[8,14,13,49],[7,75],[6,66],[5,65],[3,58],[2,48],[2,33],[2,30],[2,28],[1,28],[1,28],[1,28],[1,28],[1,27],[1,27]],[]
for l in a:
c=' '
b.append([])
for i in l:
b[-1].append(c*i)
c=[' ','#'][c==' ']
b[4]=b[4][:2]+[' OBJECTION!!']+b[4][2:]
for l in b: print ''.join(l)
```
**Output**
```
####################
#################### ############################
#################### ###########################
####################### #######################
##################### OBJECTION!! ############################
######################## ################################
###################### ########################################
################### ##########################################
############## #################################################
###########################################################################
##################################################################
#################################################################
##########################################################
################################################
#################################
##############################
############################
############################
############################
############################
############################
###########################
###########################
```
Of course, based on:
It's not a particularly novel method of generating the output, nor is it fantastic ASCII art (it looks more like a gun than a pointer finger, and the spiky hair doesn't come across great), but there isn't enough Ace Attorney in here! :)
[Answer]
## Game Maker Language
```
a=" "
b=a+a+a
c=b+b
d="------"
show_message(a+" _=====_"+c+a+" _=====_# "+a+"/ _____ \"+c+a+" / _____ \# +.-'_____'-."+d+d+d+d+"---.-'_____'-.+# / | | '."+a+a+"S O N Y+a+a+"' | _ | \# / ___| /|\ |___ \"+b+a+a+" / ___| /_\ |___ \#/ | | | ; __"+a+a+" _ ; | _ _ | ;#| | <--- ---> | | |__|"+a+a+" |_:> | ||_| "+a+"(_)| |#| |___ | ___| ;SELECT"+a+" START ; |___ "+a+"___| ;#|\ | \|/ | / _"+a+" ___ "+a+"_ \ | (X) | /|#| \ |_____| .','' '', |___| ,'' '', '. |_____| .' |#| '-.______.-' / \ANALOG/ "+a+"\ '-._____.-' |#|"+b+" | "+a+"|"+d+"|"+a+" |"+b+a+"#|"+b+" /\ "+a+"/ "+a" \ "+a+"/\ "+b+"|#|"+b+" / '.___.'"+a+a+"'.___.' \"+b+" |#|"+b+"/"+c+a+"\"+b+" |# \ "+a+a+"/ "+c+a+"\"+a+a+" /# \________/"+c+a+a+"\_________/")
```
**Result** (SE has too much whitespace, try copying to Notepad)
```
_=====_ _=====_
/ _____ \ / _____ \
+.-'_____'-.---------------------------.-'_____'-.+
/ | | '. S O N Y .' | _ | \
/ ___| /|\ |___ \ / ___| /_\ |___ \
/ | | | ; __ _ ; | _ _ | ;
| | <--- ---> | | |__| |_:> | ||_| (_)| |
| |___ | ___| ;SELECT START ; |___ ___| ;
|\ | \|/ | / _ ___ _ \ | (X) | /|
| \ |_____| .','' '', |___| ,'' '', '. |_____| .' |
| '-.______.-' / \ANALOG/ \ '-._____.-' |
| | |------| | |
| /\ / \ /\ |
| / '.___.' '.___.' \ |
| / \ |
\ / \ /
\________/ \_________/
```
] |
[Question]
[
**This question already has answers here**:
[Build a polyglot for Hello World](/questions/10695/build-a-polyglot-for-hello-world)
(9 answers)
Closed 9 years ago.
**The Setup**
Jim the student who attempts to use Stack Overflow to do his homework has asked how to get his program to say "Hello World" in under 100 lines of code, you decide mere mortal trolling is not enough...
**The Challenge**
You need to provide Jim with a program less than 100 lines long that outputs a satisfactory answer in another language. Bonus points for additional languages.
**The Rules**
1. Max 100 lines of code
2. 10 points for successfully outputting the answer in another language
3. +1 point for every additional language answer is provided for
4. Honorable mentions will be given to the most creative, most evil, and most unorthodox answers
5. Challenge ends 23:59pm GMT 3/14/2014 (results provided a few hours post challenge)
The winner is Michael who converted between six languages first
I also will give an honorable mention for cleverness to McMillin for using one command that works in several languages
I also give an honorable mention to Comintern... I don't actually know if brownies is a language, but I think we can agree it was unorthodox.
I don't think any of the answers qualifies as evil, but for the sake of it everyone who used brainfuckery will be considered recipients.
[Answer]
## Bash
```
echo Bonjour tout le monde
```
Outputs "Hello World" in a language called [French](http://en.wikipedia.org/wiki/French_language).
[Answer]
## JavaScript to C to PHP to JavaScript to Brainfuck to HQ9+
```
atob("bWFpbigpe3B1dHMoImVjaG8gXCJjb25zb2xlLmxvZygnKysrKysrWz4rKysrKysrKysrKys8LV0+LicpO1wiOyIpO30=")
```
This outputs :
```
main(){puts("echo \"console.log('++++++[>++++++++++++<-]>.');\";");}
```
Which outputs :
```
echo "console.log('++++++[>++++++++++++<-]>.');";
```
Which outputs :
```
console.log('++++++[>++++++++++++<-]>.');
```
Which outputs :
```
++++++[>++++++++++++<-]>.
```
Which outputs :
```
H
```
Which outputs :
```
Hello World!
```
[Answer]
## C# -> [Chef](http://www.dangermouse.net/esoteric/chef.html) -> German\Brownies
```
using System;
using System.Text;
namespace Greetings
{
class Program
{
static string[] ingredients = {" vegetable oil "," eggs "," boiling water "," vanilla "," cocoa powder "," flour "," sugar "," baking soda "," salt "};
static string[] measures = {" tablespoons"," dashes"," heaped tablespoons",""," pinches"};
static int[] amounts = {154,32,157,127,110,145,164,141,154};
static int[] units = {0,3,0,1,2,2,2,4,4};
static int[] steps = {4,7,0,8,2,1,3,5,0,6};
static void Main(string[] args)
{
StringBuilder sb = new StringBuilder("Fudge Brownies.\n\nThis recipe makes an absurd amount of brownies for one person.\n");
sb.Append("\nPre-heat oven to 175 degrees Celsius.\n\nIngredients.\n");
for (int i = 0; i < ingredients.Length; i++)
{
sb.Append(amounts[i]);
sb.Append(measures[units[i]]);
sb.Append(ingredients[i]);
sb.Append("\n");
}
sb.Append("\nMethod.\n");
for (int i = 0; i < steps.Length; i++)
{
sb.Append("Put");
sb.Append(ingredients[steps[i]]);
sb.Append("into the mixing bowl.\n");
}
sb.Append("Liquefy contents of the mixing bowl.\nPour contents of the mixing bowl into the baking dish.\n");
sb.Append("\nCooking time: time 40 minutes.\n\nServes 1.");
Console.WriteLine(sb);
}
}
}
```
The C# code above outputs the Chef code below (which is also [a pretty tasty brownie recipe](http://allrecipes.com/recipe/fudgy-brownies-i/)).
```
Fudge Brownies.
This recipe makes an absurd amount of brownies for one person.
Pre-heat oven to 175 degrees Celsius.
Ingredients.
154 tablespoons vegetable oil
32 eggs
157 tablespoons boiling water
127 dashes vanilla
110 heaped tablespoons cocoa powder
145 heaped tablespoons flour
164 heaped tablespoons sugar
141 pinches baking soda
154 pinches salt
Method.
Put cocoa powder into the mixing bowl.
Put baking soda into the mixing bowl.
Put vegetable oil into the mixing bowl.
Put salt into the mixing bowl.
Put boiling water into the mixing bowl.
Put eggs into the mixing bowl.
Put vanilla into the mixing bowl.
Put flour into the mixing bowl.
Put vegetable oil into the mixing bowl.
Put sugar into the mixing bowl.
Liquefy contents of the mixing bowl.
Pour contents of the mixing bowl into the baking dish.
Cooking time: time 40 minutes.
Serves 1.
```
The hardest part was doing the unit conversions on the recipe, and it really does make an absurd amount of brownies, even for a whole bunch of people. When run through a [Chef interpreter](https://metacpan.org/release/Acme-Chef), it outputs:
```
Hallo Welt
```
Or, "Hello World" in German. I'm not sure if "brownies" technically constitutes a language. If it does, it probably isn't Turing complete.
[Answer]
# Fortran 95 to Batch back to Fortran 95
```
open(unit=11,file="FOO.BAT")
write(11,"(A)") "@ECHO OFF"
write(11,"(A)") 'ECHO print*, "Hello World!"; end > BAR.F95'
call SYSTEM("FOO.BAT")
call SYSTEM("gfortran BAR.F95 -o BAR.EXE")
call SYSTEM("BAR.EXE")
end
```
This code produces a file named FOO.BAT, and then executes it automatically. This .BAT file will generate another file named BAR.F95, which is a Fortran code. This code is automatically compiled and executed, finally producing the phrase "Hello World!"
[Answer]
# C++/JavaScript/Python 3
A oneliner:
```
int main(){puts("alert(\"print(\\\"Hello World!\\\")\")");}
```
Output is a program in JavaScript that outputs the basic Hello World program in Python 3.
[Answer]
**Perl/Ruby/Python(2)/Fortran/SML**
```
print "Hello World";
```
] |
[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/19430/edit).
Closed 5 years ago.
[Improve this question](/posts/19430/edit)
Given an integer n as input write a program to output the numbers of digit in it.
**Input**
```
12346
456
```
**Output**
```
5
3
```
**Constraint**
```
n<=10^9
```
[Answer]
# GolfScript, 1 character
```
,
```
`,` means length...
Edit: You seem to have changed your question... please don't do that, but I still have a solution:
# GolfScript, ~~12~~ 7 characters (for multiline)
```
n%{,n}/
```
Thanks @Howard for reminding me about `n` to push newline and using separate strings instead of one, to save 5 chars ;)
Solutions that work with negative numbers:
# GolfScript, 5 (for negative)
```
'-'-,
```
# GolfScript, 11 (for multiline and negative)
```
n%{'-'-,n}/
```
[Answer]
# Perl
```
s/\D//;$_=length
```
run as:
```
perl -ple 's/\D//;$_=length'
```
[Answer]
I'm trying to stay away from the simple string length functions, but the BF solution basically does a count.
# Pure math/Mathematica - 22 chars (for mathematica)
```
floor(log10(abs(n)))+1
```
Thanks to @plg for the correction when n is a power of 10.
This invokes undefined behavior when n=0, but that case can be returned by a simple check.
# PHP implementation of the above math solution - 34 chars
```
($n==0)?1:floor(log(abs($n),10))+1;
```
# BrainF\*ck - 54 characters
```
>>+[<+>++++++++++,----------]<-<++++++++[>++++++<-]>.
```
[Answer]
# Dc: 3 characters
```
?Zp
```
Sample run:
```
bash-4.2$ dc -e '?Zp' <<< '12346'
5
bash-4.2$ dc -e '?Zp' <<< '345'
3
```
[Answer]
## python 2, 25
```
print len(`abs(input())`)
```
works for both positive and negative integers
[Answer]
# PHP (30 chars)
echo `$n<0?(strlen($n)-1):strlen($n)`
(without php opening tags `<?php` & `?>`)
## Explanation
Pretty simple, ints can be interpreted as strings, therefore `$n<0` has a minus-char that should be removed in the true-statement of the ternary operator. If its positive then we just count the length ;)
[Answer]
# Java 8, ~~29~~ 28 bytes
```
i->(""+(i<0?-i:i)).length();
```
# Ungolfed test program
```
public static void main(String[] args) {
IntFunction<Integer> func = i -> ("" + (i < 0 ? -i : i)).length();
System.out.println(func.apply(12345)); //5
}
```
[Answer]
## R, 25 bytes
```
cat(nchar(scan("stdin")))
```
[Answer]
# Perl (with `-lp`) (11 bytes, counting `lp`)
```
$_=length
```
[Answer]
## Befunge-98, 8 or 12 chars
**Single number** (actually counts input bytes ≥15 and prints count at EOF)
```
#.~f`+#@
```
**Multiline support** (same as above, but print count at byte <15 and reset counter)
```
#@~f`:2*j\.+
```
[Answer]
# C - 59 characters
```
main(k){scanf("%i",&k);printf("%i\n",(int)log10(abs(k))+1);}
```
[Answer]
A DELPHI PROGRAM FOR CONSOLE
```
program P;
{$APPTYPE CONSOLE}
uses
System.SysUtils;
var a: Integer;
begin
readln(a);
writeln(length(IntToStr(a)));
end.
```
[Answer]
**Ruby**
```
$*.first.size
```
or
```
ARGV.first.size
```
[Answer]
## Go, 67 bytes
```
package main;import."fmt";func main(){s:="";Scan(&s);Print(len(s))}
```
[Answer]
# Python 2, 22 bytes
```
lambda a:len(`abs(a)`)
```
I actually built this myself, before seeing Wasi's answer! This is how I thought of it:
* I need: a `lambda`.
* `len`? `False`! What about `n<0`? Should the `-` be counted? `False`!
* How to eliminate the `-` in just a few bytes? `abs`!
*[Thinking ends]*
[Answer]
# k [7 chars]
```
f:{#$x}
```
Example:
```
f 12346
5
f 456
3
```
Though only 2 characters (#$) are required to find the length of the input number.
```
#$123444
6
```
# Explanation
convert the input to string.
```
$123456
"123456"
```
count the number of characters:
```
#$123456
6
```
Q equivalent of this code:
```
f:{count string x}
f 123456
6
```
[Answer]
# JavaScript, 20
```
alert((""+n).length)
```
[Answer]
### R
The solution at 18 characters (identical in concept to the python solution of Wasi):
```
nchar(abs(scan()))
```
And the funnier one at 33 characters:
```
which(!abs(scan())%/%10^(1:9))[1]
```
[Answer]
## [GTB](http://timtechsoftware.com/gtb "GTB"), 3
Assuming value is already stored:
```
l?_
```
To make user input:
```
`_l?_
```
Newline support with interactive input:
```
[`_~l?_]
```
[Answer]
# bash - 19 characters
Assuming input via standard input:
```
grep -o [0-9]|wc -l
```
Multi-line version - 48 characters:
```
while read L;do echo $L|grep -o [0-9]|wc -l;done
```
[Answer]
### Perl
### 15 chars - no input or constraint checks
```
$_=()=$_=~/\d/g
```
### 48 chars - checks input & constraint
```
$_=/^-?(\d+)$/?($1<=10**9?length($1)."\n":$_):$_
```
NB. If the input (`$_`) is an integer (positive or negative) and comes under the constraint then it amends `$_` to the number of digits. Otherwise it just leaves the input as is.
Usage example:
```
perl -ple '... insert above code...'
```
[Answer]
### APL - 4 characters
```
ρ'n'
```
The first symbol, rho, checks the number of cells in an array, where one character of a string is equal to one cell.
[Answer]
## C, 63 59 57 characters
It's slightly longer than the other C solution, but it works on arbitrarily large numbers (numbers with `2^32 - 1` digits rather than numbers up to `2^32 - 1`).
EDIT: It's now shorter than the other C solution!
```
c;main(n){n-10?main(getchar(),c+=n>47):printf("%d\n",c);}
```
Note: if you call the program with exactly 9 arguments, it will fail. But why would you do that??
[Answer]
## PowerShell (25)
```
($n-replace"-",'').length
```
where $n is a number
[Answer]
# [Tcl](http://tcl.tk/), 26 bytes
```
puts [string length $argv]
```
[Try it online!](https://tio.run/##K0nO@f@/oLSkWCG6uKQoMy9dISc1L70kQ0ElsSi9LPb///@GRsYmZgA "Tcl – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 2 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
þg
```
[Try it online](https://tio.run/##MzBNTDJM/f//8L70//91DY2MAQ) or [verify all test cases](https://tio.run/##MzBNTDJM/X9u6//D@9L/xx7a/T/a0MjYxExHwcQUSOgCOToKBkCGpWUsAA).
**Explanation:**
```
þ # Take the digits of the input
g # And output the length
```
[Answer]
# Japt, 2 bytes
```
ìl
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=7Gw=&input=LTEyMzQ1)
`ì` converts to a digit array and `l` gets the length.
[Answer]
# [RProgN 2](https://github.com/TehFlaminTaco/RProgN-2), 2 bytes
```
âL
```
Gets the length of the Absolute Value of the input. Trivial.
[Try it online!](https://tio.run/##Kyooyk/P0zX6///wIp/////rGpoaGAEA "RProgN 2 – Try It Online")
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 5 bytes
```
!s*dl
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/9fsVgrJef///@6RpamFmamAA "Braingolf – Try It Online")
As with all the others, `abs` then `len`
[Answer]
# [Thing](https://gitlab.com/gnu-nobody/Thinglang), 12 bytes
```
idh\-=[tLe]L
```
[Try it online!](https://tio.run/##K8nIzEv//z8zJSNG1za6xCc11uf///@6pgA "Thing – Try It Online")
## How?
Gets input from command line arguments. If the first character of input is "-", push the length of the all but first items of the string and immediately end the program. Else, push the length of the string. Then implicitly print.
Does not work with multiline.
```
i push input
d duplicate
h first character of
\- push the character "-"
= if top two values are equal, push 1, if not, 0
[ if top value is truthy (not [] or 0), go into the block. if not, go past the end of the block.
t push the all but first items of the stack's top value (literally s[1:] in python)
L length
e end the program
] end loop
L length
```
] |
[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/61390/edit).
Closed 8 years ago.
[Improve this question](/posts/61390/edit)
Hopefully not duplicate, but I did not find one.
# Challenge
The challenge is to write full program, which compiles (without errors), but, when executed, will not finish the execution till the end, because an error appears during the execution.
# Rules
* It has to be full program, which is compile-able or interpret-able in such way, that it produces no syntax errors.
* You can use any mechanics, which will do something, so that the interpreter of your program kills the program. This includes (but is not limited to): exceptions, overflows, SIGSEGVs. However, asking the interpreter to kill the program explicitly does not count (by calling `exit()`-like functions).
* It may be compiler/OS dependent, as long as it's not using obvious bug in compiler/interpreter. So depending on Undefined behavior in C/C++ is valid, but using version 1.0.17b of `language` interpreter, which throws `random_exception` when run is not. If it depends on something, it's good to write so in the answer.
* The program will take no input, but it may (or may not) produce any output to STDOUT, or STDERR.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), but it is not about finding the language with least amount of bytes, but to find a least bytes solution in all languages. So I will not accept any answer.
# Catalogue
I hope [Martin Büttner](https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner) won't get mad at me for copy-pasting [his](https://codegolf.stackexchange.com/questions/55422/hello-world) catalogue.
The Stack Snippet at the bottom of this post generates the catalogue from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
/* Configuration */
var QUESTION_ID = 61390; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 43365; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
return "http://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
return "http://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
jQuery.ajax({
url: answersUrl(answer_page++),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
answers.push.apply(answers, data.items);
answers_hash = [];
answer_ids = [];
data.items.forEach(function(a) {
a.comments = [];
var id = +a.share_link.match(/\d+/);
answer_ids.push(id);
answers_hash[id] = a;
});
if (!data.has_more) more_answers = false;
comment_page = 1;
getComments();
}
});
}
function getComments() {
jQuery.ajax({
url: commentUrl(comment_page++, answer_ids),
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
answers_hash[c.post_id].comments.push(c);
});
if (data.has_more) getComments();
else if (more_answers) getAnswers();
else process();
}
});
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
return a.owner.display_name;
}
function process() {
var valid = [];
answers.forEach(function(a) {
var body = a.body;
a.comments.forEach(function(c) {
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});
var match = body.match(SCORE_REG);
if (match)
valid.push({
user: getAuthorName(a),
size: +match[2],
language: match[1],
link: a.share_link,
});
else console.log(body);
});
valid.sort(function (a, b) {
var aB = a.size,
bB = b.size;
return aB - bB
});
var languages = {};
var place = 1;
var lastSize = null;
var lastPlace = 1;
valid.forEach(function (a) {
if (a.size != lastSize)
lastPlace = place;
lastSize = a.size;
++place;
var answer = jQuery("#answer-template").html();
answer = answer.replace("{{PLACE}}", lastPlace + ".")
.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)
.replace("{{LINK}}", a.link);
answer = jQuery(answer);
jQuery("#answers").append(answer);
var lang = a.language;
lang = jQuery('<a>'+lang+'</a>').text();
languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
});
var langs = [];
for (var lang in languages)
if (languages.hasOwnProperty(lang))
langs.push(languages[lang]);
langs.sort(function (a, b) {
if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
return 0;
});
for (var i = 0; i < langs.length; ++i)
{
var language = jQuery("#language-template").html();
var lang = langs[i];
language = language.replace("{{LANGUAGE}}", lang.lang)
.replace("{{NAME}}", lang.user)
.replace("{{SIZE}}", lang.size)
.replace("{{LINK}}", lang.link);
language = jQuery(language);
jQuery("#languages").append(language);
}
}
```
```
body { text-align: left !important}
#answer-list {
padding: 10px;
width: 290px;
float: left;
}
#language-list {
padding: 10px;
width: 290px;
float: left;
}
table thead {
font-weight: bold;
}
table td {
padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="language-list">
<h2>Shortest Solution by Language</h2>
<table class="language-list">
<thead>
<tr><td>Language</td><td>User</td><td>Score</td></tr>
</thead>
<tbody id="languages">
</tbody>
</table>
</div>
<div id="answer-list">
<h2>Leaderboard</h2>
<table class="answer-list">
<thead>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
</thead>
<tbody id="answers">
</tbody>
</table>
</div>
<table style="display: none">
<tbody id="answer-template">
<tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
<tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
</tbody>
</table>
```
[Answer]
## C, 5 bytes
```
main;
```
On modern systems it will crash because `main` is not in an executable section. On older systems it will execute some junk and crash.
[Answer]
## Brainfuck, 1 byte
`[`
There's no matching `]` to jump to. Depending on how smart your compiler/interpreter is, it may give you a syntax error, but the original spec didn't allow for syntax errors - only runtime errors.
[Try it online](http://ideone.com/Is7b3c)
[Answer]
# Python, 1 byte
```
_
```
NameError! :D
This works because NameErrors in Python occur at *run-time*, NOT *compile-time*.
[Answer]
# CJam, 1 bytes
```
;
```
This will try to pop from an empty stack.
[Try it online.](http://cjam.aditsu.net/#code=%3B)
[Answer]
# JavaScript Shell, 7 bytes
```
clear()
```
The `clear` function has been quite controversial but to clarify this uses the *SpiderMonkey* shell. It will throw a `Segmentation fault: 11`
[Answer]
# PHP, 7 Bytes
```
<?=o();
```
This Santa smiley crashes with `Fatal error: Call to undefined function o() in [...]`
[Answer]
# C#, 36 bytes
```
class C{static void Main(){Main();}}
```
Throws a `StackOverflowException`. I can't remove the main function and still have it compile.
[Answer]
# JavaScript, 1 byte
```
_
```
Tries to access the undefined variable `_`, which raises a ReferenceError. JS doesn't check for inexistent variables until runtime, so if you tried this code:
```
console.log("No error??/")
_
console.log("Huh...")
```
It would error out with `ReferenceError: _ is not defined`, then print `No error??/`, but not `Huh...`.
[Answer]
# T-SQL, 9 bytes
```
EXEC('@')
```
Causes the following error
```
Msg 137, Level 15, State 2, Line 1
Must declare the scalar variable "@".
```
[Answer]
# Pyth, 3 Bytes
```
/00
```
### Result:
>
>
> ```
> Traceback (most recent call last):
> File "pyth.py", line 671, in <module>
> File "<string>", line 3, in <module>
> File "/app/macros.py", line 506, in div
> ZeroDivisionError: integer division or modulo by zero
>
> ```
>
>
[Answer]
# [PoGo](http://esolangs.org/wiki/PoGo), 2 Bytes
```
vi
```
### Result
>
>
> ```
> EXCEPTION_INT_DIVIDE_BY_ZERO
>
> ```
>
>
[Answer]
# C++, 23 bytes
```
int main() {
main();
}
```
Crashes with `Segmentation fault: 11`
[Answer]
# Haskell, 10 bytes
```
main=[]!!0
```
Fails with the `Prelude.!!: index too large` error.
[Answer]
## STATA, 1 byte
`a`
Outputs `unrecognized command: a`, but this error occurs at run-time.
For an error not in the range 100 to 199 (considered syntax errors), use
```
set ob `=9^9'
```
This gave me the following to standard error:
`op. sys. refuses to provide memory
Stata ran out of room to track where observations are stored. Right now, Stata has 1m bytes allocated to track observations. Stata
requested an extra 738m bytes (in 738 1m pieces) and the operating system said no. Stata is currently tracking 0 observations and was
asked to track 0. You are up against the memory limits of this computer.`
[Answer]
# Loader, 8 bytes
There are shorter solutions, but this is the shortest one that's actually legal syntax:
```
throw ""
```
Throws the empty string as an error message (which, in the reference implementation, corresponds to a popup error notification reading `Error:` followed by a single trailing space).
] |
[Question]
[
It's simple, simply write the shortest code to raise a `TypeError`.
In Python you can do:
```
raise TypeError
```
However it should be shorter with a code that gives a `TypeError` without raising it.
[Answer]
```
for chr1 in range(32, 128):
for chr2 in range(32, 128):
for chr3 in range(32, 128):
code = chr(chr1) + chr(chr2) + chr(chr3)
try:
output = exec(code, {})
except TypeError:
print(code)
except:
pass
```
[Try it online!](https://tio.run/##dY1BCsIwEEX3nuIvE@ymyUYEl97AC5Q42m6SMJ1Cg3j2aKTRCrr78N6biUn64G3Ol8BwPbcYPLjzV1LWNGjNTu83wELNb/rm9h8HXDgTDkVS5Y3Gtm6z2lYvunCqJRAmiZM8a5rJqXKpwe1eVZodRcEpRToyB/50kQcvL//bXRndOOb8AA "Python 3 – Try It Online")
A naive search may result that you cannot trigger a TypeError within 2 characters. You may get a TypeError with 3 characters. All solutions including:
## 1. Math operator, non-numeric types
* Math operator including `+`, `-`, `~`
* Non-numeric types including `""`, `()`, `[]`, `id`, `{}`
```
+[]
-""
~id
```
## 2. Invoke number as function
```
0()
```
## 3. Matrix multiplication between numbers
`@` is `__matmul__` in python, [read more here](https://stackoverflow.com/questions/6392739/what-does-the-at-symbol-do-in-python)
```
0@0
```
## 4. Binary operator with float / complex number
```
~0.
~.0
~0j
```
## 5. Iterate over number
Thanks to [@Dennis](https://codegolf.stackexchange.com/users/12012/dennis) to point out this.
You may iterate some variable by star operator. And `()` for a tuple may be omitted.
```
*0,
```
[Answer]
# [JavaScript (V8)](https://v8.dev/), 4 bytes
```
1.()
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/31BPQ/P///8A "JavaScript (V8) – Try It Online")
# [Output]
`.code.tio:1: TypeError: 1 is not a function
1.()
^
TypeError: 1 is not a function
at .code.tio:1:3`
[Answer]
# [Python 3](https://docs.python.org/3.7/), 3 bytes
```
+''
```
[Try it online!](https://tio.run/##K6gsycjPM/7/X1td/f9/AA)
[Answer]
## Python, 3 bytes
This is self-explanatory. The unary - operator does not take a string argument. This was covered in @tsh's solution above.
```
-""
```
[Try it online!](https://tio.run/##K6gsycjPM/7/X1dd/f9/AA)
Another one:
```
~id
```
[Try it online!](https://tio.run/##K6gsycjPM/7/vy4z5f9/AA)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 1 [byte](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Throws `TypeError: U.í is not a function`
```
í
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=7Q) (Errors are displayed below the output field)
---
Or, a bit less trivial:
## [Japt](https://github.com/ETHproductions/japt), 2 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Throws `TypeError: (U++) is not a function`
```
°(
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=sCg)
[Answer]
# Python 3, 3 bytes
```
+[]
```
It gives an `TypeError: bad operand type for unary +: 'list`
[Answer]
# [Python 3](https://docs.python.org/3.7/), 3 bytes
```
0()
```
raises a `TypeError`
] |
[Question]
[
You're writing your favorite language and you want to display the following string: `abcdefghijklmnopqrstuvwxyz` to your happy customer. Unfortunately, your keyboard is broken and you can now only type symbols `!+-*/[]()`.
You must submit a code that evaluates to be the string `abcdefghijklmnopqrstuvwxyz` or print the string `abcdefghijklmnopqrstuvwxyz` and contain only symbols `!+-*/[]()`. For example, `+![]+[]` in javascript evaluates to be the string `0`.
The shortest valid submission in 7 days wins. If there're multiple ones, I'll accept the one with the earliest last modification time. Good luck!
[Answer]
# [Lenguage](https://esolangs.org/wiki/Lenguage), \$1.5161 \times 10^{27}\$ characters
*Everyone's* favourite language when short of available characters!
A program consisting of *any* 1516111794593168227366643743 characters will print `abcdefghijklmnopqrstuvwxyz` then exit.
This is because that length in binary, left padded to a multiple of 3 bits with zeros is:
```
001 001 110 011 000 011 001 001 010 010 001 001 001 001 001 111
011 001 001 001 001 001 011 110 001 001 010 100 000 011 111
```
Which translated from Binaryfuck to Brainfuck is this **~~50 49 41~~ 31 character** program:
```
--[<+<-->>-----]<-----<[-->.+<]
```
Which we can easily **[try online!](https://tio.run/##SypKzMxLK03O/v9fVzfaRttGV9fOThcEYm3AlE00UERP2yb2/38A "brainfuck – Try It Online")**
### How?
Brainfuck starts with an infinite tape of zeros, which may be incremented or decremented (\$0\$ decrements to \$255\$ and \$255\$ increments to \$0\$).
`[...]` or `]` are ignored if the value under the head is \$0\$ otherwise `]` loops back to its matching `[`
`>` and `<` move the head right and left respectively.
`.` prints the value under the head as a character.
```
--[<+<-->>-----]<-----<[-->.+<] | print the alphabet - tape = ". . n A x . ."
-- | x -= 2 -> x = 254
[ ] | while x != 0:
<+ | move to A; A += 1
<-- | move to n; n -= 2
>>----- | move to x; x -= 5
| -> 254//5 + 1 + 255//5 = 102 loops
| leaving n = 52, A = 102, x = 0
<----- | move to A; A -= 5
< | move to n
[ ] | while n != 0:
-- | n -= 2
>. | move to A; print character(A)
+< | A += 1; move to n
| -> 52//2 = 26 loops, printing 'abc...xyz'
```
---
It might just be quicker to order a new keyboard though.
[Answer]
## [W](https://github.com/A-ee/w) `c`, 149 bytes
DISCLAIMER: This answer has *nothing* to do with the water closet.
The `c` flag `c`onfuses the interpeter with strings and character arrays, therefore outputting the lowercase alphabet. Note that I already had this idea before this challenge.
How to enter an empty input: just type `""` as the input, W will not recognize this operand.
```
]+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
```
## Explanation
After compilation, it looks like this:
```
] % Roll the whole stack into a list (surrounding the input).
% The stack: []
+ % W is short of operands, so an implicit argument is added.
% The input is 0 by default if it's empty.
% The stack: [0]
) % Increment all (automatically vectorizes)
% The stack: [1]
+ % Join with the implicit input
% The stack: [0,1]
)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+
% After all that boring stuff, the stack becomes:
% [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
97+
% For clarity the 97 )'s are converted to addition. Stack:
% [97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122]
Flag:C % Convert the numeric array to a string
% Output: abcdefghijklmnopqrstuvwxyz
```
```
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 396 bytes
```
((((((((((((((((((((((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])[()])
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fAzfQHHlQM1pDM3bAiP///@s6AgA "Brain-Flak (BrainHack) – Try It Online")
## Explanation
This answer is pretty simple. We push `z` by doing a bunch of `()`s
```
( () × 122 )
```
Then we use that as a starting place to count down each letter subtracting one each time.
```
( ... [()])
```
Where the `...` is the code that pushed all the letters prior.
The unfortunate thing is that the structure of the goal string actually makes it a lot harder to do anything fancy. `[]` is basically useless since by the time we have anything on the stack we just want to count down. And as if that weren't enough all of the fun operations `{...}`, `{}` and `<>` are unusable.
This answer is likely optimal for brain-flak (without using `-r`).
# [Brain-Flak -r](https://github.com/DJMcMayhem/Brain-Flak), 296 bytes
```
((((((((((((((((((((((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())())())())())())())())())())())())())())())())())())())())())())())())())())
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/XwM30BzqkJro////uo5FAA "Brain-Flak – Try It Online")
## Explanation
This works like the last one except we start at `a` and count up. This is cheaper since `a` has a smaller code point and adding one is cheaper than subtracting one. It saves exactly 100 bytes because there are 26 letters in the alphabet, going down to 'a' from 'z' saves 2 bytes per letter down which is 50 and changing minus one to plus one saves 2 bytes per letter, which is another 50.
The one issue is that this method does put things in the reverse order so we need `-r` to correct it, which is a flag that just reverses the order that things are output.
[Answer]
# Javascript, ~~19793~~ ~~9031~~ 3318 chars
```
(![]+[])[+!![]]+([][(!![]+[])[!![]+!![]+!![]]+([][[]]+[])[+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([![]]+[][[]])[+!![]+[+[]]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[!![]+!![]+!![]]]()+[])[!![]+!![]]+([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+([][[]]+[])[!![]+!![]]+(!![]+[])[!![]+!![]+!![]]+(![]+[])[+[]]+(+(!![]+!![]+!![]+[!![]+!![]+!![]+!![]]+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(!![]+!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+(+!![])+(+[])+(!![]+!![])+(!![]+!![]+!![]+!![]+!![]+!![])+(+!![])+(+!![])+(!![]+!![]+!![])))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]](!![]+!![]+[!![]+!![]+!![]+!![]+!![]+!![]+!![]])+(!![]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(+(!![]+!![]+!![]+!![]+!![]+[!![]+!![]+!![]]+(!![]+!![]+!![]+!![]+!![]+!![])+(+[])+(!![]+!![]+!![]+!![]+!![])+(+!![])+(+!![])+(!![]+!![]+!![]+!![]+!![])))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+([]+[])[([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+(!![]+[])[+!![]]][([][[]]+[])[+!![]]+(![]+[])[+!![]]+([]+(+[])[([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+([][[]]+[])[+!![]]+(![]+[])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[!![]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!![]+!![]]+(![]+[])[+!![]]+(!![]+[])[+[]]])[+!![]+[+[]]]+(!![]+[])[+!![]]])[+!![]+[+!![]]]+(!![]+[])[!![]+!![]+!![]]]](!![]+!![]+!![]+[!![]+!![]+!![]+!![]+!![]+!![]])
```
See, this is what happens when people can't be bothered to write javascript by hand. They use [generators](https://jscrew.it). Still, that was an interesting challenge!
A better generator dropped over ~~10k~~ 16k chars. Wow.
] |
[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/34556/edit)
**EDIT:** The behavior may be inconsistent. Also, associative arrays are permitted.
Make a function that iterates through an indexed array, mapping a function of a single argument to each member of the array. The catch: introduce a hidden bug where the function is not correctly applied to at least one index of the input array.
Example:
```
map(lambda a: a+1, [1, 2, 3, 4])
# Should be [2, 3, 4, 5]
# Could be: [2, 3, 5, 4] or [2, 4, 6, 5] or anything else
```
Rules:
1. Use either a static method with two arguments, function and array, or a non-static method with one, an array or function (`this` being of the other type). Examples:
* `std::vector<F> map(F (*fn)(E), std::vector<E> array);` (C++)
* `def map(fn, array): ...` (Python)
* `Array.prototype.map = function (fn) {...};` (JavaScript)
2. If your language features a method already to do this, re-implement it.
3. The ignored entry may be of any type desired.
4. Assume the arguments to actually be correct (if the language has dynamic type checking).
5. It may or may not be in place.
6. Hide your malice.
7. Highest vote count wins.
Here's an example of a correct, bug-free implementation in JavaScript (excluding type checking):
```
Array.prototype.map = function (fn) {
var i = this.length,
ret = new Array(i);
while (i--) { // decrements to 0 after evaluation
ret[i] = fn(this[i]);
}
return ret;
};
```
[Answer]
## Perl
```
sub mymap (&@) {
my $fn = shift;
my @ret;
while (my $val = shift) {
local $_ = $_[0]; # map calling convention is element in $_
push @ret, $fn->();
}
return @ret;
}
```
Looks plausible for at least a moment, until you have the sense to go "why isn't he using `$val`?"
[Answer]
## Javascript
Let's use Object.defineProperty to define a lazy map function that only evaluates its result the first time it is requested.
```
function map(arr, f) {
var result = {};
for (var i = 0; i < arr.length; i++) {
var value = arr[i], evaluated;
Object.defineProperty(result, i, {
get: function () {
if (!evaluated) {
evaluated = f(value);
}
return evaluated;
}
});
}
result.length = arr.length;
return result;
}
// Used like this
var x = map([1, 2, 3], function (x) { return x + 1; });
```
>
> The code has a pretty common error that often occurs when defining functions inside loops - since JS does not introduce a new context in a for loop, the variables `i`, `value`, and `evaluated` are the same for all the 'get' functions. This means that all elements in the result will be the same, namely `f(arr[arr.length - 1])`. Not very sneaky, but an interesting quirk of JS.
>
>
>
Addition:
>
> Sneaky bug #2: if `f(arr[arr.length - 1])` returns falsey, accessing an element in the array will apply `f` again! So sneaky I didn't realize it myself when writing up the sample.
>
>
>
[Answer]
I thought I'd try to take a stab at my own challenge here...please pardon my long spoilers.
# JavaScript
It's a bit simplified compared to the spec (it requires type checking and `this` isn't necessarily an Array instance)
```
Array.prototype.map = function (fn) {
var ret = [];
for (var i in this) {
ret.push(fn(i));
}
return ret;
};
```
Sounds great! Where's the problem?
>
> It is widely known in the JavaScript world that the for-in loop returns the indices of arrays, not the entries. The confusion still brings headaches, even to some more seasoned developers.
>
> Also, in past versions of IE, for-in loops also iterated over additional properties, such as Array.prototype.toString.
>
> The proper way to fix this bug would be to use `this[i]` instead of `i` and append `if (this.hasOwnProperty(i)), so that it looks like this:
>
>
> ```
>
> Array.prototype.map = function(fn) {
> var ret = [];
> for (var i in this) {
> if (this.hasOwnProperty(i)) {
> ret.push(fn(this[i]));
> }
> }
> return ret;
> };
>
> ```
>
> This looks correct now?
>
>
>
>
>
>
> Try again. If there is any enumerable property ever assigned to the array, this loop will also see it and apply the function to it. That is relatively easy to do, considering the two standard means of setting properties default to being enumerable (which you can't change this way, either):
>
>
> ```
>
> object.prop = val;
> object['prop'] = val;
>
> ```
>
> Keep in mind that you can assign a property to anything in JavaScript. If you were to try that "correct" implementation on a standards-comforming browser you would get this:
>
>
>
> ```
>
> var old = [1, 2, 3, 4, 5];
> old.foo = 'Hi!';
> var new = old.map(function (a) {return a + 1;});
> console.log('Old length: ' + old.length);
> console.log('New length: ' + new.length);
> console.log('Old contents: ' + old); // implicit toString
> console.log('New contents: ' + new);
>
> ```
>
>
> ```
>
> Output:
> Old length: 5
> New length: 6
> Old contents: 1,2,3,4,5
> New contents: 2,3,4,5,6,Hi!1
>
> ```
>
> Also, there is no guarantee that the for-in loop iterates in order. The `push()` method implies the need to be in order. This could mean that the last line could very well print out the contents as `2,6,4,3,Hi!1,5`.
>
>
> The only way to define a non-enumerable property is through `Object.defineProperty()`, `Object.defineProperties()`, `Object.create()`, and the like.
>
>
> Moral of the story, never use for-in loops to iterate through arrays. It's a code smell, and a terrible one at that. It leads to misunderstanding and bugs. It was clearly designed for associative arrays, not indexed ones. This should prove it. Always use the more standard for loop. Not only is it quicker, it is harder to screw up with. The for loop should have been:
>
>
>
> ```
>
> for (var i = this.length - 1; i > 0; i--) {
> ret[i] = this[i];
> }
>
> ```
>
> Ironically, this *could* be done out of order.
>
>
>
>
>
[Answer]
# C-sharp
So since this function will ship with a large library (really!), we'll have to keep it as generic as possible - it even works for [non-zero based arrays](http://escapelizard.wordpress.com/2013/10/16/10-things-you-maybe-didnt-know-about-c/) (first entry)!
```
public U[] Map<T, U>(T[] inArray, Func<T, U> fn)
{
U[] outArray = new U[inArray.Length];
for (int i = inArray.GetLowerBound(0); i < inArray.GetUpperBound(0); i++)
outArray[i] = fn(inArray[i]);
return outArray;
}
```
>
> So obviously the '<' in the for-loop should be '<='. An array with 2 elements has an upperbound of 1. The idea behind this trick is that everyone is used to writing 'i = 0; i < a.len', and will hopefully miss this detail at the first glance. The last entry in the outArray will remain zero.
>
>
>
[Answer]
Here's a nice broken recursive lisp function:
```
(defun xmap (l f) (when (cdr l) (cons (funcall f (car l)) (xmap (cdr l) f))))
```
>
> `(cdr l)` will be `NIL` when `l` has one element, so the base case is a single-element list (in which the return value is nothing). Therefore, the output list is mapped from every element of the input list, except the last one.
>
>
>
This solution has the delightful property of being one letter different from a working function. Happy debugging with 3AM tired eyeballs!
[Answer]
# C++
Let's have fun with some meta programming.
```
template <class ...Args>
struct Helper;
// base case for Helper
template <class F, class T>
struct Helper<F, T, std::tuple<>> {
using type = std::tuple<T>;
};
template <class F, class T, class ...Args>
struct Helper<F, T, std::tuple<Args...>> {
using t1 = typename F::template apply<T>;
using type = std::tuple<t1, Args...>;
};
template <class F, class ...Args>
struct Map;
// base case for Map
template <class F>
struct Map<F, std::tuple<>> {
using type = std::tuple<>;
};
template <class F, class T, class ...Args>
struct Map<F, std::tuple<T, Args...>> {
using type = typename Helper<F, T, typename Map<F, typename std::tuple<Args...>>::type>::type;
};
```
Usage:
```
struct Func {
template <class T>
using apply = typename std::add_rvalue_reference<T>::type;
};
Map<Func, std::tuple<int, double , int const>>::type t;
// t suppose to have type std::tuple<int&&, double&&, int const&&>
// but it is std::tuple<int&&, double&&, int const>
```
The `Map` struct is a meta function that can apply another meta function to the types of a `tuple`, except the last member...
[in Coliru](http://coliru.stacked-crooked.com/a/318a6b253dba5fe8)
>
> While the base case for `Map` is required to handle empty tuple, the base case for `Helper` isn't really helpful. Delete it will make everything working again.
>
>
>
[Answer]
# PowerShell
I spent two hours trying to think of ways to be tricky with PowerShell, so I hope this isn't too easy to see through. Shouldn't be too hard to figure out what I did here.
```
function Map-Array($inArray, $functionName){
$outArray = $inArray.Clone()
$inArray.GetLowerBound(0)..($inArray.GetUpperBound($inArray.Rank-1)-1)|%{$outArray[$_-1] = & $functionName $([char]$inArray[$_-1])}
$outArray
}
function Black-Box($in){[char](([int]$in)-32)}
$x=@('a','b','c','d','e','f')
$y = Map-Array -inArray $x -functionName 'Black-Box'
```
Black-Box capitalizes all letters in the char array $x, anything else it just rolls back 32 spots on the ASCII table.
However...
```
-join $y
ABCDeF
```
>
> Went a little overboard with my array index checking heh.
> Mainly because I like the fact that an index of -1 automatically points to the last element in the array in Powershell.
>
>
>
[Answer]
**JS**
(after a little editing, because first was second and second was first but now first is more... interesting)
Let me borrow the OP's code, however due to our company's naming policy we need to change the name:
```
Array.prototype.array_map = function (fn) {
var i = this.length,
ret = new Array(i);
while (i--) { // decrements to 0 after evaluation
ret[i] = fn(this[i]);
}
return ret;
};
var a = [1,2,3].array_map(function(x){ return x+1 });
console.log(a);
```
`[2, 3, 4, array_map: function]`
What's this rubbish?
>
> The problem lies with definition of properties on objects. Array is an
> object in JS (or should I say Object). While `map` property is
> defined (or undefined if your browser is very old), JS has no problems
> with overwriting it and while the value of it will change (from one
> function to the other) the properties of this property won't (`map`
> isn't enumerable). Creating another method on `Array.prototype` by
> default defines this property as enumerable and as such is
> "accessible" (or - displays) like any other value of the array. Adding
> call to defineProperty solves this problem:
>
>
> ```
> var a = [1,2,3].array_map(function(x){ return x+1 }); console.log(a);
> [2, 3, 4, array_map: function]
> ```
>
>
> ```
> Object.defineProperty(Array.prototype, "array_map", {enumerable : false});
> var b = [1,2,3].array_map(function(x){ return x+1 }); console.log(b);
> [2, 3, 4]
> ```
>
>
>
>
---
I always felt that there should be `map` on objects (associative arrays for you non-JS folks). As there's no such method in JS this code golf gave me the opportunity to write one.
First, let's define method length, as there's no such method in JS on objects as well (sheesh, JS, c'mon):
`Object.prototype.length = function() {
var size = 0;
for (var key in this)
size++;
return size;
}`
Now, let's do this!
```
Object.prototype.map = function (f) {
var r=this;
for (var i=0; i<this.length(); i++)
if (this[i])
r[i] = f(this[i]);
return r;
}
```
Seriously, I don't know why JS didn't have it before. Now, let's test it!
```
var a = {O: 1, 1: 2, 2: 3};
console.log(a, 1);
console.log(a.map(function(x){ return x+1 }), 2);
Object {1: 2, 2: 3, O: 1, length: function, map: function} 1
Object {1: 3, 2: 4, O: 1, length: function, map: function} 2
```
Perfect!
>
> I hope this didn't give too much headache to any of you JS developers out there. This code is riddled with problems - creating methods on Object (big no no), implementation of length (object doesn't actually have length, as methods on given object are part of the object - you can see that in the output itself; you can count the property indexes but this is not the way to do it), but the offending problem is actually a malice on my part - actually the O in the a objects isn't 0. While we're creating r as a copy of object, by iterating through it via for loop we're assigning values to all numeric elements, but r[0] isn't there.
>
>
>
[Answer]
## Clojure
A simple, lazily evaluating map (basically a simplified version of Clojure's map).
```
(defn map' [f coll] (if (next coll) (lazy-seq (cons (f (first coll)) (map' f (rest coll))))))
(map' #(* % %) [0 1 2 3 4 5])
=> (0 1 4 9 16)
```
>
> You would probably want to check if the collection is empty, without dropping one element from it. `(next coll)` returns `nil` if the collection has one element in it. Correct behaviour could be gained by using `(seq coll)`.
>
>
>
[Answer]
# PHP
```
function map($arr, $func){
foreach($arr as &$x)
$x = $func($x);
$result = array();
foreach($arr as $x)
$result[] = $x;
return $result;
}
```
>
> This one is obvious to those who know PHP. `$x` is still a reference to the last item after the first loop.
>
>
>
[Answer]
## Python
Um, since the question says "at least one":
```
ma = lambda m:[1]*len(m)
```
---
Slightly foolproofed:
```
def ma(p, f):
return [0] + ma(p[1:],f) if m[0]==1 else [1] * len(m)
```
---
I know, I know, bring on the downvotes.
Here's another:
```
ma = lambda m,f:[f(x) for x in range(len(p))]
```
] |
[Question]
[
I just created a language on the spot, and it's called "interpreter". Called as such because the only valid word is "interpreter"!
A sample program in "interpreter" looks like this:
```
interpreter interpreterinterpreter interpreterinterpreterinterpreter interpreterinterpreterinterpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreterinterpreter
```
It may look meaningless, but the language works like:
* `interpreter` initializes the accumulator to zero.
* `interpreterinterpreter` adds one to the accumulator.
* `interpreterinterpreterinterpreter` subtracts one from the accumulator.
* `interpreterinterpreterinterpreterinterpreter` multiplies the accumulator by 2.
* `interpreterinterpreterinterpreterinterpreterinterpreter` divides the accumulator by 2.
* `interpreterinterpreterinterpreterinterpreterinterpreterinterpreter` outputs the accumulator.
## Rules
* Standard loopholes are forbidden.
* Shortest program in **bytes** wins.
* Your program should work for all test cases.
* You may assume that all code entered is valid.
* The first command will always be `interpreter`.
* There will always be a single space between each command.
* Floating point division, not integer division.
* Trailing newlines are allowed.
## Testcases
```
interpreter interpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreterinterpreter -> 1
interpreter interpreterinterpreter interpreterinterpreter interpreterinterpreterinterpreterinterpreter interpreterinterpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreterinterpreter -> 3
interpreter interpreterinterpreterinterpreterinterpreterinterpreter interpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreterinterpreter -> 1
interpreter interpreterinterpreter interpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreterinterpreter interpreterinterpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreterinterpreter interpreter interpreterinterpreter interpreterinterpreterinterpreterinterpreterinterpreterinterpreter -> outputs 2, then outputs 1, then outputs 1
```
[Answer]
# [JavaScript (V8)](https://v8.dev/), 71 bytes
```
s=>s.split` `.map(i=>(n=i.length%6)?s=[,s/2,s*2,s-1,s+1,0][n]:print(s))
```
[Try it online!](https://tio.run/##1VNNC8IwDL3vV4SK0LqufhxEHJ0n/4G3MVgZnavMWZqyi/jb58CLN5kOxUPCSwjk5YV3Uq3Cwhnro3bTlbJDmaBAWxufQy7OylIjE9pII2rdHH01XbMdypTjfMVx1ke05Bgu@SJLm2xrnWk8Rca6OA0ASF9pZ53uMzzh1@0hkPCPVg1iACNMjHbQu1z@TPMffgK@I2aQBaK8uL0qKkqRg2EgE7jCw07koNFDoVDDhEAIYWhYDGVvsxhurLsD "JavaScript (V8) – Try It Online")
### How?
The length of an *interpreter* instruction is \$11\times k,\:1\le k \le 6\$, which gives \$[11,22,33,44,55,66]\$. When applying a modulo \$6\$, this maps to \$[5,4,3,2,1,0]\$. This is shorter than dividing by \$11\$ and allows us to easily identify the *output* instruction (size \$66\$, mapped to \$0\$) which behaves differently from the other ones.
---
# [JavaScript (V8)](https://v8.dev/), 80 bytes
This version is also based on the length of the instruction modulo \$6\$ but doesn't use any lookup table. It updates the accumulator with a single statement, using arithmetic and bitwise operations.
This is rather pointless in JS but [does save a few bytes in C](https://codegolf.stackexchange.com/a/219835/58563) (as opposed to a chain of ternary operators).
```
s=>s.split` `.map(i=>(n=i.length%6)?A=A*(6&9/n|n<2)/2+(3>>n-3^2)-2:print(A),A=0)
```
[Try it online!](https://tio.run/##1VPLCsIwELz3K5aKktiXRBBfifTgH3gTpaGkNlJjSIIX9dtrwYs3qYriZRiGhZ2dYff8xG1upHbRaVwXtLaU2djqSroMsvjANZKUIUVlXAm1c2V3hBcpTfto1Jsk6qLmBCckQEPGVDTcEhyRqTZSOZTiMKUDXM/WHoDfKMJoIxqEB/5cbkP98K1VrRzAByY@dtCrXv4s8x82Ad8J09t4cXE0S56XCNkQJAbK4Az3l/JXwjrIuRXQ8SGAIJB4BgWyDV5xfQM "JavaScript (V8) – Try It Online")
```
| n = | multiply by: | add:
operation | length % 6 | (6&9/n|n<2)/2 | (3>>n-3^2)-2
-----------+------------+---------------+--------------
clear | 5 | 0 | 0
increment | 4 | 1 | 1
decrement | 3 | 1 | -1
double | 2 | 2 | 0
halve | 1 | 0.5 | 0
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~113~~ \$\cdots\$ ~~113~~ 111 bytes
Saved ~~3~~ 6 bytes thanks to the man himself [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!!
Added 6 bytes to accommodate floating-point division.
Saved 2 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!
```
float a;c;f(char*s){for(;*s;c?a=a*(6&9/c|c<2)/2+(3>>c-3^2)-2:printf("%f ",a),++s)for(c=1;*++s&&*s-32;c=++c%6);}
```
[Try it online!](https://tio.run/##1VRta8IwEP7urzgKLUnT4tqCMGPdp/2K1UE4E1dwbWkCk7n@9XVprU5kMBSZLB@Oy91zr@EJhivEtlXrUhgQHLki@CJqX9OtKmvCfc3xQaTCJxPvfowfOIvpOGYkmc8xTJ5jGsbTqs4Lo4jjKnACQQPGNO2CMY24by@e5@swiTmmjKE7obxpbQC8irwgdLQdgT19UTBSG/20gBS2joXIuqqllXCk/24@R3UCuLzQWfXhCogrjXNpJ/9q3zd8BfibVTb8iDlyU0k0cjmQJ@oWnXSi12KIINoHWGoC6QiYF0u5sfA7Pqgz0Pm7LBXZZ6PjweAfLBwY69EUdsw9Yq/NtWNwD1jwE7@0/kOfp5D9J5I5rs6crHjsgXoKbqazwg5hApD0G6@IoT9EF@HNj@126KwZNe0nqrVY6TZ8@wI "C (gcc) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~18~~ 17 bytes
```
#€g"=;·<>0"sè».Võ
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f@VHTmnQlW@tD223sDJSKD684tFsv7PDW//8z80pSiwqKUoGkAhKbbGFSmApUUEGSEbTzCgA "05AB1E – Try It Online")
+2 bytes thanks to a bug, corrected by Makonede
-1 byte thanks to Command Master!
## How it works
```
#€g"=;·<>0"sè».Võ - Program. Push the input I to the stack
# - Split I on spaces
€g - Lengths of €ach
"=;·<>0" - Push "=;·<>0"
s - Swap, moving the lengths to the top of the stack
è - Index into string, 0-based and modularly
» - Join by newlines
.V - Run as 05AB1E code
õ - Push the empty string
```
This takes a similar approach to my [Jelly answer](https://codegolf.stackexchange.com/a/219843/66833), translating into 05AB1E then running. This only beats Jelly because the increment commands can go in strings in 05AB1E, but not in Jelly
We don't need to bother with any syntax nonsense to reset the accumulator in 05AB1E. Instead, as all the commands operate on the top value, we just push a 0 to the top of the stack
| interpreter command | Equivalent 05AB1E command | What it does in 05AB1E |
| --- | --- | --- |
| `interpreter` | `0` | Pushes `0` to the ToS (top of stack) |
| `interpreterinterpreter` | `>` | Increments the ToS |
| `interpreterinterpreterinterpreter` | `<` | Decrements the ToS |
| `interpreterinterpreterinterpreterinterpreter` | `·` | Doubles the ToS |
| `interpreterinterpreterinterpreterinterpreterinterpreter` | `;` | Halves the ToS |
| `interpreterinterpreterinterpreterinterpreterinterpreterinterpreter` | `=` | Prints the ToS without popping it |
We push an empty string at the end to prevent implicit output. If nothing has been output by the transpiled interpreter code, 05AB1E would output the ToS. We push the empty string so that if no output has been produced, 05AB1E outputs the empty string instead
[Answer]
# [PHP](https://php.net/), ~~128~~ ~~105~~ ~~90~~ 86 bytes
```
foreach(explode(' ',$argn)as$v)($i=strlen($v)%6)?$c-=[0,$c/2,-$c,1,-1,$c][$i]:print$c;
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLUhOTMzRSKwpy8lNSNdQV1HVUEovS8zQTi1XKNDVUMm2LS4pyUvM0gDxVM017lWRd22gDHZVkfSMdXZVkHUMdXUMgLzZaJTPWqqAoM69EJdn6/38gnVpUUJQKJBWQ2GQLk6uYJOOwM//lF5Rk5ucV/9d1AwA "PHP – Try It Online")
~~Actually counting the number of parts split by `p` rather than counting `interpreter`, so that any word that contains "p" would work.~~
EDIT: saved 23 bytes by using an array (inspired by other answers)
EDIT 2: another 15 bytes with @Arnauld the Great's modulo 6. Basically a port of his answer now
EDIT3: 4 bytes less with an array of values to subtract instead of an array to assign
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~120~~ 71 bytes
```
o=(. =0 ++ -- *=2 /=2)
for i;do
((x${o[n=${#i}/11]},n-6))||echo $x
done
```
[Try it online!](https://tio.run/##S0oszvifpqFZ/T/fVkNPwdZAQVtbQVdXQcvWSEHf1kiTKy2/SCHTOiWfS0OjQqU6PzrPVqVaObNW39AwtlYnT9dMU7OmJjU5I19BpYIrJT8v9X8tF1eaQmZeSWpRQVEqkERmExYmhUmJPSRZr0AFFYR9Q5R3yHUJVRwIjmclW1uFnMTiEoXkxOJUKwVbWyUuukXEAEYPfZL0//8A "Bash – Try It Online")
### Credits
* Saved 4 bytes from both answers thanks to @Neil
* Saved 49 bytes thanks to @DigitalTrauma
[Answer]
# [Python 3](https://docs.python.org/3/), ~~138~~ bytes
Easy translation of the *interpreter language* instructions:
```
for i in[len(o)/11for o in input().split(' ')]:
if i==1:a=0
if i==2:a=a+1
if i==3:a=a-1
if i==4:a=a*2
if i==5:a=a/2
if i==6:print(a)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/SCFTITMvOic1TyNfU9/QECSSDxQBooLSEg1NveKCnMwSDXUFdc1YKy6FzDSFTFtbQ6tEWwMYxwjISdQ2hHGNQVxdONcExNUygnFNQVx9ONfMqqAoM69EI1Hz/38gnVpUUJQKJBWQ2ISFSWFykW0LSZYrUEEFNfxCrjOo4DoA "Python 3 – Try It Online")
In the first line:
1. takes the input
2. split the instructions separated by a space
3. divide by 11 (the lenght of the base word `interpreter`) to get the corresponding operation
The subsequent `if` execute the operations on the accumulator.
*EDIT:* theoretical improvements, code not modified (see version 2). Anyway, thanks for the suggestions!
*-4 bytes thanks to @expressjs123*
*-3 bytes thanks to @ElPedro*
---
**VERSION 2**
# [Python 3](https://docs.python.org/3/), ~~97~~ ~~96~~ 93 bytes
Improved the selection of the instructions simply by using list slicing.
*-41 bytes compared to original version.*
*-1 byte thanks to @ElPedro*
*-3 bytes thanks to @Zaelin Goodman*
```
a=0
for i in[len(o)//11for o in input().split()]:
a-=[a,-1,1,-a,a/2,0][i-1]
if i>5:print(a)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9HWgCstv0ghUyEzLzonNU8jX1Nf39AQJJQPFAKigtISDU294oKcTCAda8WlkKhrG52oo2uoY6ijm6iTqG@kYxAbnalrGMulkJmmkGlnalVQlJlXopGo@f8/kE4tKihKBZIKSGzCwqQwuci2hSTLFaigghp@IdcZQyekBzD8FejiFQA "Python 3 – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `rDO`, 13 bytes
```
⌈vL`…½d‹›0`İĖ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=rDO&code=%E2%8C%88vL%60%E2%80%A6%C2%BDd%E2%80%B9%E2%80%BA0%60%C4%B0%C4%96&inputs=interpreter%20interpreterinterpreter%20interpreterinterpreter%20interpreterinterpreterinterpreterinterpreterinterpreterinterpreter%20interpreterinterpreterinterpreter%20interpreterinterpreterinterpreterinterpreterinterpreterinterpreter%20interpreter%20interpreterinterpreter%20interpreterinterpreterinterpreterinterpreterinterpreterinterpreter%20interpreterinterpreter&header=&footer=)
Vyxal port of [@caird coinheringaahing’s 05AB1E answer](https://codegolf.stackexchange.com/a/219846/101522).
Explanation:
```
# Implicit input
‚åà # Split on " "
vL # Length of each command
`…½d‹›0` # Push "…½d‹›0" 'D' flag - treat as raw string
İ # Index into string
Ė # Exec as Vyxal code
# 'O' flag - disable implicit output
The commands in `…½d‹›0`:
… - Print without popping
¬Ω - Halve
d - Double
‹ - Decrement
› - Increment
0 - Push 0
```
[Answer]
# [PHP](https://php.net/), 80 bytes
```
foreach(explode(' ',$argn)as$v)$a-=[$a/2,-$a,1,-1,$a][strlen($v)%6-1]??!print$a;
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLUhOTMzRSKwpy8lNSNdQV1HVUEovS8zQTi1XKNFUSdW2jVRL1jXR0VRJ1DHV0DYGysdHFJUU5qXkaQAWqZrqGsfb2igVFmXklKonW//8D6dSigqJUIKmAxCZbmBSmAhVUkGQE7bzyL7@gJDM/r/i/rhsA "PHP – Try It Online")
**Explanation**
```
$a // accumulator
-= // subtract operation result and assign to accumulator
[$a/2,-$a,1,-1,$a] // array of operations (divide, multiply, subtract, add, reset)
[strlen($v)%6-1] // modulo 6 of command length, minus 1
// this way the print command (-1) will not be present in array
?? // array key does not exist?
!print$a; // print accumulator and toggle the boolean value of print's return
// toggle is required, because print always returns 1
// and we don't want to modify accumulator value, so !1 == 0
```
**Credits**
* Main idea for performing commands from [Kaddath's answer](https://codegolf.stackexchange.com/a/219818/100869)
* Modulo operation from [Arnauld's answer](https://codegolf.stackexchange.com/a/219817/100869)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 bytes
```
ḲẈị“HḤ“øȮ”j⁾’‘¤Vṛ“
```
[Try it online!](https://tio.run/##y0rNyan8///hjk0Pd3U83N39qGGOx8MdS4DU4R0n1j1qmJv1qHHfo4aZjxpmHFoS9nDnbKDM////M/NKUosKilKBpAISm2xhUpgKVFBBkhG08woA "Jelly – Try It Online")
## How it works
```
ḲẈị“HḤ“øȮ”j⁾’‘¤Vṛ“ - Main link. Takes a string I on the left
·∏≤ - Split I at spaces
Ẉ - Get the length of each section
¤ - Group into a nilad:
“HḤ“øȮ” - [["H", "Ḥ"], ["ø", "Ȯ"]]
⁾’‘ - ["’", "‘"]
j - Join; ["H", "Ḥ", "’", "‘", "ø", "Ȯ"]
ị - Index into the string, modularly and 1-indexed
V - Execute as Jelly code
“ - Yield the empty string
·πõ - Replace with the empty string to suppress automatic output
```
This program translates interpreter into Jelly and then runs it as Jelly code. First, only the lengths of each command actually matter. The lengths are `[11, 22, 33, 44, 55, 66]`, which are unique modulo 6. The commands are transliterated as follows:
| interpreter command | Length | Length mod 6 | Jelly command |
| --- | --- | --- | --- |
| `interpreter` | 11 | 5 | `√∏` |
| `interpreterinterpreter` | 22 | 4 | `‘` |
| `interpreterinterpreterinterpreter` | 33 | 3 | `’` |
| `interpreterinterpreterinterpreterinterpreter` | 44 | 2 | `Ḥ` |
| `interpreterinterpreterinterpreterinterpreterinterpreter` | 55 | 1 | `H` |
| `interpreterinterpreterinterpreterinterpreterinterpreterinterpreter` | 66 | 0 | `Ȯ` |
As Jelly uses modular indexing, we don't need to bother to modulo the lengths, we can just go ahead and into the command list.
Most of these commands are pretty obvious and are direct translations from the spec (e.g. `‘` is Jelly's increment command, `Ḥ` is double etc.). However, `ø` is slightly different (and I think this is the only time I've every used it).
`√∏` is a syntax command that tells Jelly to begin a new niladic chain. This basically tells Jelly to throw away everything before it and to reset, using `0` as the argument for the new command. As we're outputting as we go, its actually perfectly fine to "throw away" the previous commands, because they're no longer relevant.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~84~~ 82 bytes
```
n=0
for c in input().split():l=len(c)%10;n+=[-n,1,-1,n,-n/2,0][l-1];l==6==print(n)
```
[Try it online!](https://tio.run/##rU9BCsMgELz7Ci9FbbXVBnpI2JeIp2CpIBsxKaSvt7an3kqCsOwOwzAzm17LY8KurMAYKwia3KdMRxqwTnouXJznFEO9fYTokY/iYPSAJ7AKpZHKSJQKL1epnY3KuCEC3ABSDrhwFKXakq9n@Hha7Y5dT6hf/chXUarI55R93fQH/6e3QLI7ZVM4baBo8cveGg3avQE "Python 3 – Try It Online")
-2 bytes Oliver Ni
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 31 bytes
```
Ｆ⪪Ｓ ≡№ιi¹≔⁰θ²≦⊕θ³≦⊖θ⁴≦⊗θ⁵≦⊘θ⟦Ｉθ
```
[Try it online!](https://tio.run/##tY89C8IwEEB3f8XhlEAFP5c6iQ52EARHcYhprIGYtMlFB/G3x4gKLbhUdDmO9x4Hx4/McsNUCAdjgWxKJZFkuvS4QSt1QWgCXehSCu4ikR@BzI3XSGTE8oGvHc6cgEEKM@dkoUk/gYpOn3SYwoqVL5FpbsVJaBR5LRnVk4X4lIwbifF71dCTul4ydX7bXByYV5jCOn6CZDtnDklFd1HdQohI2NKKOKG2f43brPCDotWJ/73SCb2zugM "Charcoal – Try It Online") Explanation:
```
Ｆ⪪Ｓ
```
Split the input on spaces and loop over each word.
```
≡№ιi
```
Count the number of `i`s in each word.
```
¹≔⁰θ²≦⊕θ³≦⊖θ⁴≦⊗θ⁵≦⊘θ⟦Ｉθ
```
Perform the appropriate operation on the accumulator depending on the number of `i`s.
Note that a `switch` is shorter than looking up the results in an array as I don't have to initialise the accumulator.
[Answer]
## Batch, 206 bytes
```
@set/ps=
@set t=@set "s=
%t%%s:nterpreter=%
%t%%s: =&set/an%
%t%%s:set/aniiiiii=call:c%
%t%%s:iiiii=/=2%
%t%%s:iiii=*=2%
%t%%s:iii=-=1%
%t%%s:ii=+=1%
%t%%s:i==0%
@set/an%s%
@exit/b
:c
@echo %n%
```
Takes input on STDIN. Works by performing substitutions on the input string to produce Batch code which is then executed.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + GNU utils, 89
Transpiles to `dc`, then interprets:
```
sed -r 's/\S{11}/x/g;s/x{6}/p/g;s/x{5}/2\//g;s/x{4}/2*/g;s/xxx/1-/g;s/xx/1+/g;s/x/0/g'|dc
```
[Try it online!](https://tio.run/##S0oszvj/vzg1RUG3SEG9WD8muNrQsFa/Qj/duli/otqsVr8AyjSt1TeK0YdyTIAcLQi7okLfUBfK1DfUhrD0DfTT1WtSkv//z8wrSS0qKEoFkgpIbMLCpDC5yLaFJMsVqKCCGn4h1xlDJ6QHMPwV6OIVAA "Bash – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 83 -> 73 -> NOW 59 bytes
```
$args|% Le*|%{,$a*!($_%6);$a-=(0,($a/2),-$a,1,-1,$a)[$_%6]}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XyWxKL24RlXBJ1WrRrVaRyVRS1FDJV7VTNNaJVHXVsNAR0MlUd9IU0dXJVHHUEfXEKhCMxqkILb2////mXklqUUFRalAUgGJTbYwuYpJMg47EwA "PowerShell – Try It Online")
Thanks to @mazzy and @ZaelinGoodman
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 29 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
¸®=Êu6)?E=[,E/2EÑEÉEÄT]gZ:OpE
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=uK49ynU2KT9FPVssRS8yRdFFyUXEVF1nWjpPcEU&input=WyJpbnRlcnByZXRlciBpbnRlcnByZXRlcmludGVycHJldGVyIGludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlciIsImludGVycHJldGVyIGludGVycHJldGVyaW50ZXJwcmV0ZXIgaW50ZXJwcmV0ZXJpbnRlcnByZXRlciBpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlciBpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXIgaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyIiwiaW50ZXJwcmV0ZXIgaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlciBpbnRlcnByZXRlcmludGVycHJldGVyIGludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlciIsImludGVycHJldGVyIGludGVycHJldGVyaW50ZXJwcmV0ZXIgaW50ZXJwcmV0ZXJpbnRlcnByZXRlciBpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXIgaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyIGludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlciBpbnRlcnByZXRlciBpbnRlcnByZXRlcmludGVycHJldGVyIGludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlcmludGVycHJldGVyaW50ZXJwcmV0ZXJpbnRlcnByZXRlciJdCi1tCg)
* port of [@Arnauld answer](https://codegolf.stackexchange.com/a/219817/84844) so upvote him!
[Answer]
# [YaBASIC](http://www.yabasic.de), 130 bytes
```
dim c$(1)
n=split(i$,c$())
for j=1 to n
c=mod(len(c$(j)),6)
if c a=a*or(and(6,9/c),c<2)/2+xor(mod(3/2^(c-3),6),2)-2
if !c ?a;
next
```
A basic interpreter interpreter running in an interpreted Basic interpreter...
[Try it online!](https://tio.run/##7VPLCsIwELznK9YimNWUYsSCaPVPhDWJENG0pDno19dUL96kPlDBSxhmM5PJZnOiDdVWNdvSgy3GEEqYMm9Ig@2zQeWtCxGJBNIlJPNG2wOoPh8jc0Vd7W3gsRgJRNY67K4OjqniUGq@N47H4g5R5MjsFhRQQcPSc3Ka52KWKRRqITGTo2NkW80kk2uu0kkrERJT2ep6ClY0Z84cQ3PJdIFgmaZAkETC@MqbuMINvk93gcmzh3XKAC/Y8cIrPZrm5/r@wdeA32jnd0zF39m/79d2mqfmDA "Yabasic – Try It Online")
Well, thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)'s infamous MOD 6 trick, I was able to compress this perfectly readable, easily maintained and expandable 134 byte program:
```
dim c$(1)
n=split(i$,c$())
for j=1 to n
c=len(c$(j))/11
if c=1 a=0
if c=2 a=a+1
if c=3 a=a-1
if c=4 a=a*2
if c=5 a=a/2
if c=6 ?a;
next
```
into the 130-byte bit of opaque confusion seen above! ü§£ If I was gonna develop "interpreter" as a product, I know which code-base I'd start with, but really, I'd rather program in DeadFish...
[Answer]
# [Perl 5](https://www.perl.org/) `-a`, 66 bytes
```
eval((0,'$a=0','$a++','$a--','$a*=2','$a/=2','say$a')[y/i//])for@F
```
[Try it online!](https://tio.run/##K0gtyjH9/z@1LDFHQ8NAR10l0dZAHURpa4MpXV0wpWVrBKb1wXRxYqVKorpmdKV@pr5@rGZafpGD2///mXklqUUFRalAUgGJTbYwuYpJMg47819@QUlmfl7xf11fUz0DQ4P/uokA "Perl 5 – Try It Online")
[Answer]
# Java, ~~137~~ 129 bytes
```
s->{var x=0d;int l;for(var w:s.split(" ")){if((l=w.length()/11)==6)System.out.println(x);x-=new double[]{x,-1,1,-x,x/2,0}[l-1];}}
```
[Try it online!](https://tio.run/##tVA9b4MwEN3zK05MuAUndOhQ4iyZO2VEDK5jiKkxyD6CK8Rvp66Cqq6p2pPO9/ne3bnhV5425/elH960EiA0dw5euTIwbSDImnfIMZhrp87Qhmp8QqtMXZTAbe3I2vwlTWCkAypNq8EIVJ2hx864oZV2fwMdQLDFpYdJGQTPdonOq86ujDC@OOp6rTCOICJk0mykWpoaLzHZZlmuqlgz9kxOHw5lS7sBaR@AqE3sSe6ZkSOEsCinXeIfs8SnQR@eEr8NOhc6zcp8npf8e2FBuRCyD/MCTNreyvDCD//X6Xtc@IOOuyj@75SI3D533szLJw)
*Saved 8 bytes thanks to [branboyer](https://codegolf.stackexchange.com/users/94107).*
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 12 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
î╜║µI*▄mß┘r>
```
[Run and debug it](https://staxlang.xyz/#p=8cbdbae6492adc6de1d9723e&i=interpreter+interpreterinterpreter+interpreterinterpreterinterpreterinterpreterinterpreterinterpreter%0A%0Ainterpreter+interpreterinterpreter+interpreterinterpreter+interpreterinterpreterinterpreterinterpreter+interpreterinterpreterinterpreter+interpreterinterpreterinterpreterinterpreterinterpreterinterpreter%0A%0Ainterpreter+interpreterinterpreterinterpreterinterpreterinterpreter+interpreterinterpreter+interpreterinterpreterinterpreterinterpreterinterpreterinterpreter%0A%0Ainterpreter+interpreterinterpreter+interpreterinterpreter+interpreterinterpreterinterpreterinterpreterinterpreterinterpreter+interpreterinterpreterinterpreter+interpreterinterpreterinterpreterinterpreterinterpreterinterpreter+interpreter+interpreterinterpreter+interpreterinterpreterinterpreterinterpreterinterpreterinterpreter%0A&m=2)
Who needs flags when *compression*? :P
] |
[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/17785/edit).
Closed 10 years ago.
[Improve this question](/posts/17785/edit)
# Task
Write some code that will walk through the entire file-system tree and collect details from file-names, folder-names, text files etc to form a tag-group. This tag group, when searched in (user input) should point to the folders they are located in.
# Rules
1. Any Language (standard libraries only).
2. Any kind of output (should be legible).
3. You may extend your code by reading more file-types and their metadata.
4. Regex is allowed
# You'll win
1. +14 points for the shortest code (will be taken away when some else beats the record)
2. +6 for each added functionality (anything you could possibly claim).
3. -2 for each byte exceeding 1024 byte mark.
# Example
```
Python (using os module - os.walk)
```
input
```
Enter search term below
>>> *camp*
```
output
```
Total results for *camp* = 2
-------------------------------
Camping.avi - "C:\Users\Amelia\Videos\Summer Camping"
Campus party.avi - "C:\Users\Public\Campus"
```
[Answer]
## BASH, 14 + 6\*18 = 122
Cheap, but a win.
```
locate
```
Example:
```
boothby@not ~ $ locate camp
/home/boothby/Desktop/kodak/Pictures/camp.jpg
/home/boothby/Desktop/kodak/Pictures/camp2.jpg
/home/boothby/Downloads/sage-5.12/local/share/doc/networkx-1.7.dev_20131124172629/examples/graph/napoleon_russian_campaign.py
/usr/src/linux-headers-3.8.0-19/arch/arm/plat-samsung/include/plat/camport.h
/usr/src/linux-headers-3.8.0-33/arch/arm/plat-samsung/include/plat/camport.h
```
Feature: this is super efficient since it caches the file information in a database. The above runs on my computer in 0.187s.
... and 17 additional features:
```
-b, --basename
Match only the base name against the specified patterns. This
is the opposite of --wholename.
-c, --count
Instead of writing file names on standard output, write the num‐
ber of matching entries only.
-d, --database DBPATH
Replace the default database with DBPATH. DBPATH is a :-sepa‐
rated list of database file names. If more than one --database
option is specified, the resulting path is a concatenation of
the separate paths.
An empty database file name is replaced by the default database.
A database file name - refers to the standard input. Note that
a database can be read from the standard input only once.
-e, --existing
Print only entries that refer to files existing at the time
locate is run.
-L, --follow
When checking whether files exist (if the --existing option is
specified), follow trailing symbolic links. This causes broken
symbolic links to be omitted from the output.
This is the default behavior. The opposite can be specified
using --nofollow.
-h, --help
Write a summary of the available options to standard output and
exit successfully.
-i, --ignore-case
Ignore case distinctions when matching patterns.
-l, --limit, -n LIMIT
Exit successfully after finding LIMIT entries. If the --count
option is specified, the resulting count is also limited to
LIMIT.
-m, --mmap
Ignored, for compatibility with BSD and GNU locate.
-P, --nofollow, -H
When checking whether files exist (if the --existing option is
specified), do not follow trailing symbolic links. This causes
broken symbolic links to be reported like other files.
This is the opposite of --follow.
-0, --null
Separate the entries on output using the ASCII NUL character
instead of writing each entry on a separate line. This option
is designed for interoperability with the --null option of GNU
xargs(1).
-S, --statistics
Write statistics about each read database to standard output
instead of searching for files and exit successfully.
-q, --quiet
Write no messages about errors encountered while reading and
processing databases.
-r, --regexp REGEXP
Search for a basic regexp REGEXP. No PATTERNs are allowed if
this option is used, but this option can be specified multiple
times.
--regex
Interpret all PATTERNs as extended regexps.
-V, --version
Write information about the version and license of locate on
standard output and exit successfully.
-w, --wholename
Match only the whole path name against the specified patterns.
This is the default behavior. The opposite can be specified
using --basename.
```
[Answer]
BASH
```
find
```
A cheaper, *shorter* win. See @boothby answer for examples
[Answer]
**C# - 200**
```
void G(string s){foreach (var y in Directory.GetFiles(@"C:\").Where(k => k.ToLower().Contains(s.ToLower())))foreach (var f in Directory.GetDirectories(@"C:\")){Console.WriteLine(y);try{G(f);}catch{}}}
```
[Answer]
# Groovy (59)
```
a={b-> new File("c:\\").traverse(nameFilter: ~b){print it}}
```
Call it with
```
a('test')
```
] |
[Question]
[
Your function must accept three numbers in any order:
* A signed real number (or `±Infinity`) - The number (`N`) for which you have to generate a number from the range
* A signed integer - Minimum of the range
* A signed integer - Maximum of the range
**Input**:
* The minimum of the range will always be less than the maximum of the range, so don't worry about it
* `N` can be any real (if it is possible `Infinity` and `-Infinity` also can be passed)
**Requirements**:
* Your function must output same result each time for same inputs
* Your function must output different result each time for different `N` (except when it's due to a floating point error)
* The output must be in the given range
* The outputs of your function for all numbers `N` must cover the entire range (except when missing outputs are due to floating point error)
**Please specify**:
* The order of the input
* Is it possible to pass `±Infinity` as a `N`?
* Are the minimum and maximum of the range inclusive or exclusive?
Unable to provide test cases because there are many ways to solve this problem, so please provide your test cases.
The shortest code in each programming language wins!
[Answer]
# [Python](https://www.python.org), 29 bytes
```
lambda a,b,c:a+(b-a)/(1+2**c)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhZ7cxJzk1ISFRJ1knSSrRK1NZJ0EzX1NQy1jbS0kjUham6aFxRl5pVopGnoGusYGugYaGpyoYoYYojoGgFVQbQvWAChAQ)
Does not include the upper bound.
Uses the mapping
$$f(c) = \frac{a-b}{1+2^c}+a$$
[An interactive graph of what this looks like:](https://www.desmos.com/calculator/jme6s1vlej)
[](https://i.stack.imgur.com/2cqV0.png)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 33 bytes
```
N@Rescale[#1,{-∞,∞},{#2,#3}]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7388hKLU4OTEnNVrZUKda91HHPB0grtWpVjbSUTaujVX7H1CUmVfikBZtoKNraKBjaBDLBRMxNDDAFNQ1whQCmQoV/A8A "Wolfram Language (Mathematica) – Try It Online")
Mathematica easily operates with infinities both signs, so here it is. For input infinite values you can use `\[Infinity]` or `∞` with sign.
[Answer]
# [R](https://www.r-project.org), 31 bytes
```
\(w,a,b)(.5+atan(w)/pi)*(b-a)+a
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhb7YzTKdRJ1kjQ19Ey1E0sS8zTKNfULMjW1NJJ0EzW1EyGqbqalaRjoGeok2hoa6CTZGhlocqVpGBoZm5jqmZlbWBqgSujilvHMS0MVQRWA2LZgAYQGAA) or [Try it at rdrr.io with graphical output](https://rdrr.io/snippets/embed/?code=f%3D%0Afunction(w%2Ca%2Cb)(.5%2Batan(w)%2Fpi)*(b-a)%2Ba%0A%0Ax%3Dseq(-25%2C25%2Cby%3D.1)%0Aplot(x%2Cf(w%3Dx%2Ca%3D10%2Cb%3D20))%0A)
[Answer]
# [Thunno](https://github.com/Thunno/Thunno), \$ 10 \log\_{256}(96) \approx \$ 8.21 bytes
```
-s2@1+/A$+
```
Port of [97.100.97.109's Python answer](https://codegolf.stackexchange.com/a/258882/108687)
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhardIuNHAy19R1VtCECUPEFy3WNuQwNuAwgXAA)
```
-s2@1+/A$+ # stack is min, max, wind
- # subtract
s # swap, wind is on top
2@ # 2 ^ wind
1+ # add one
/ # divide (max-min) by (1 + 2^wind)
A$+ # add the first input
```
## [Thunno](https://github.com/Thunno/Thunno), \$ 6 \log\_{256}(96) \approx \$ 4.93 bytes
```
-DZs*$
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhbLdF2iirVUIByo2IJVuibGXIbGXEZ6RhARAA)
This uses the formula `((b - a) * c) % (b - a)`, where a is the minimum of the range, b is the maximum of the range, and c is the wind. I noticed after posting this that the formula doesn't really work though.
```
-DZs*$ # stack is min, max, wind
- # subtract
D # duplicate
Zs # swap bottom two
* # multiply
$ # swapped modulus
```
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), 14 bytes
```
Ť←←Đ3Ș⇹-⇹↔⁺₂*+
```
[Try it online!](https://tio.run/##K6gs@f//6JJHbROA6MgE4xMzHrXv1AXiR21THjXuetTUpKX9/78BlwmXMQA "Pyt – Try It Online")
Takes inputs as `c b a` (each on their own line)
Uses `tanh` as the mapping function
```
Ť implicit input (c); Ťanh(c)
←← get input twice (b, then a)
Đ Đuplicate a
3Ș Șwap top three items of stack
⇹ swap top two on stack
- subtract (b-a)
⇹ swap top two on stack
↔ flip the stack
⁺ increment [tanh(c)+1]
₂ halve [(tanh(c)+1)/2]
* multiply [(b-a)*(tanh(c)+1)/2]
+ add [a+(b-a)*(tanh(c)+1)/2]; implicit print
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 13 bytes
```
ＮθＩ⁺θ∕⁻Ｎθ⊕Ｘ²Ｎ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05oroCgzr0TDObG4RCMgp7RYo1BHwSWzLDMlVcM3Mw/IR1avqaNQCMSeeclFqbmpeSWpKRoB@eVACSOQIJI6CLD@/1/XWMHQQMHgv25ZDgA "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Another port of @adam's Python answer.
```
Ｎθ First input as a number
Ｎ Second input as a number
⁻ Minus
θ First input
∕ Divided by
² Literal integer `2`
Ｘ Raised to power
Ｎ Third input as a number
⊕ Incremented
⁺ Plus
θ First input
Ｉ Cast to string
Implicitly print
```
Originally this was meant to be based on @KiptheMalamute's answer, so I started with:
$$ f(c) = a + \frac {2(b - a)} {1 + \tanh c} $$
Charcoal doesn't have hyperbolic (or indeed trigonometric) functions, so I rewrote this in terms of the exponential function:
$$ f(c) = a + \frac {b - a} {1 + e ^ {-2 c}} $$
But there's no particular reason to use \$ e^{-2} \$; any base will do, such as \$ 2 \$, which is much golfier:
$$ f(c) = a + \frac {b - a} {1 + 2 ^ c} $$
] |
[Question]
[
I'm posting my code for a LeetCode problem copied here. If you have time and would like to golf for a short solution, please do so.
### Requirement
* It has to only pass the LeetCode's Online Judge, if the language would be available.
* If the language is not available, simply we should possibly keep the `class Solution` as well as the function name.
### Languages and Version Notes
Available languages are:
* C++ clang 9 Uses the C++17 standard.
* Java 13.0.1
* Python 2.7.12
* Python3 3.8
* C gcc 8.2
* C# 8.0
* JavaScript 14.3.0
* Ruby 2.4.5
* Bash 4.3.30
* Swift 5.0.1
* Go 1.13
* Scala 2.13
* Kotlin 1.3.10
* Rust 1.40.0
* PHP 7.2
Thank you!
## Problem
>
> Given a positive integer n, return the number of all possible
> attendance records with length n, which will be regarded as
> rewardable. The answer may be very large, return it after mod 10 ^ 9 + 7.
>
>
> A student attendance record is a string that only contains the
> following three characters:
>
>
> * 'A' : Absent.
> * 'L' : Late.
> * 'P' : Present.
>
>
> A record is regarded as rewardable if it doesn't contain more than one
> 'A' (absent) or more than two continuous 'L' (late).
>
>
> ### Example 1:
>
>
> * Input: n = 2
> * Output: 8
>
>
> ### Explanation:
>
>
> There are 8 records with length 2 will be regarded as rewardable:
>
>
> * "PP" , "AP", "PA", "LP", "PL", "AL", "LA", "LL"
> * Only "AA" won't be regarded as rewardable owing to more than one absent times.
> * Note: The value of n won't exceed 100,000.
>
>
>
### Accepted Code
```
class Solution:
def checkRecord(self, n):
MOD = 1000000007
a = b = d = 1
c = e = f = 0
for _ in range(n - 1):
a, b, c, d, e, f = (a + b + c) % MOD, a, b, (a + b + c + d + e + f) % MOD, d, e
return (a + b + c + d + e + f) % MOD
```
### Accepted Golf Attempt in Python 3 - 185 bytes - I
```
class Solution:
def checkRecord(self,n):
M=1000000007;a=b=d=1;c=e=f=0
for _ in range(n-1):a,b,c,d,e,f=(a+b+c)%M,a,b,(a+b+c+d+e+f)%M,d,e
return(a+b+c+d+e+f)%M
```
### Accepted Golf Attempt in Python 3 - 185 bytes - II
```
class Solution:
def checkRecord(self,n):
M=int(1e9+7);a=b=d=1;c=e=f=0
for _ in range(n-1):a,b,c,d,e,f=(a+b+c)%M,a,b,(a+b+c+d+e+f)%M,d,e
return(a+b+c+d+e+f)%M
```
### Reference
In LeetCode's answer template, there is a class usually named `Solution` with one or more `public` functions which we are not allowed to rename.
* [Problem](https://leetcode.com/problems/student-attendance-record-ii/)
* [Discuss](https://leetcode.com/problems/student-attendance-record-ii/discuss/)
* [Languages](https://support.leetcode.com/hc/en-us/articles/360011833974-What-are-the-environments-for-the-programming-languages-)
* I guess the solution was originally designed by [Stefan Pochmann](https://codegolf.stackexchange.com/users/40544/stefan-pochmann)
[Answer]
Tips:
1. The first argument `self` can be renamed to something shorter.
2. Use `while n:n-=1` to loop `n` times
3. (Python 2 specific) You can use a single tab for the second level of indentation, instead of 2 spaces.
4. For this problem, it's sufficiently fast to just mod `b` every loop, instead of having to mod both `a` and `d`.
5. The part `a,b,c,d,e,f=...` can be broken into `a,b,c=...;d,e,f=...`, which allows reusing the updated value `a=a+b+c`
6. `c,e,f` can be initialized to `10**9+7` instead of `0` (found by @xnor).
# [Python 2](https://docs.python.org/2/), ~~136 134 131 127~~ 125 bytes
```
class Solution:
def checkRecord(_,n):
a=b=d=1;c=e=f=M=10**9+7
while n:n-=1;a,b,c=a+b+c,a%M,b;d,e,f=a+d+e+f,d,e
return d%M
```
[Try it online!](https://tio.run/##TY1BDoIwEEXX9BTdkIAdDbgxQuYIbPQApp1OA5G0pJQYT19xY3y7//7iLe80Bn/OmWa9rvIe5i1NwXdCWnaSRqbnjSlEWz3A150oNBq02PaEjA4HbJvD4aouoniN08zSd/64vxoMEGplFIEuBzC9BQa3G6tYOdiXKCKnLXppyyEvcfLpV6/q03@5bb7U@QM "Python 2 – Try It Online")
[Answer]
1. You don't need more than one space per level of indentation.
2. Observe that you have `(a+b+c+d+e+f)` used twice. This code duplication can be avoided by running the loop one more time and using `d` of the extra iteration
3. `[0]*n` is 3 bytes shorter than `range(n)`
4. It's not necessary to modulo by 1000000007 each time; you can remove it from the loop and only do it at the end (This takes about 1 second for `n=100000` on TIO, which appears to be too slow). After this, `M` will only be used once, so you can inline it into the one place it was used
---
# [Python 3](https://docs.python.org/3/), 136 bytes
```
class Solution:
def checkRecord(self,n):
a=b=d=1;c=e=f=0
for _ in [0]*n:a,b,c,d,e,f=a+b+c,a,b,a+b+c+d+e+f,d,e
return d%int(1e9+7)
```
[Try it online!](https://tio.run/##TY7BCsIwEETvfsVehMYs0uJBbNmf0KOIpMmGFsumpOnBr4@NIDinmTcMzPxOQ5BTznYyywK3MK1pDNLuwLEHO7B9XdmG6KqFJ4@itgYM9eSo6Swxeao34kOEJ4wC9/pxkNZgjxYdMnoyutcWC/k67TRrX7ptFjmtUcDtR0lVwxd9VnmOJfyOVOr4f6Kpi5TKHw "Python 3 – Try It Online")
---
Or, if the last tip is too slow:
# [Python 3](https://docs.python.org/3/), 148 bytes
```
class Solution:
def checkRecord(self,n):
M=int(1e9+7);a=b=d=1;c=e=f=0
for _ in [0]*n:a,b,c,d,e,f=(a+b+c)%M,a,b,(a+b+c+d+e+f)%M,d,e
return d%M
```
[Try it online!](https://tio.run/##TU5LCsIwFNx7ircpJCZIiwux5R2hG12KSJq80NKSlDRdePqYIIKzmx8z6zuO3p1T0ovaNrj7ZY@Td@0BDFnQI@n5RtoHwzZarHQ8O9Dj5CJr6CouvFM4oMGm00hosc629QFeMDl41M@ja5UcpJZGkrTIlBiE5lUvi/plwggStmg5k@uB4h4cmKpPayhDv1OMn/4PNXUB5@kD "Python 3 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 121 bytes
```
checkRecord(n){long a=1,b=1,d=1,c=0,e=0,f=0,x,y,m=7+1e9;for(;n--;d=y%m)x=a+b+c,y=x+d+e+f,f=e,e=d,c=b,b=a,a=x%m;return d;}
```
[Try it online!](https://tio.run/##hY5BCsMgEEX3OYUEAooGYjeliJfouhszahpaTZAUDCFnt9PSRVftwNu9//9AOwCUAlcHt7ODKVka2Xaf4kCMlqJHLAK6Ew7xSBarCPrIpTspPyWqYtsqq9cmsKwN7zmIVWduueMeAw6DFgt6LDPC6NwEldzySJFYtZdgxkjZVs1pjIundWMvsRbf/xBJGFO/hMM/QXave1uf6U5Ve3kC "C (gcc) – Try It Online")
Slightly golfed less
```
checkRecord(n){
long a=1,b=1,d=1,c=0,e=0,f=0,x,y,m=7+1e9;
for(;n--;d=y%m)
x=a+b+c,
y=x+d+e+f,
f=e,
e=d,
c=b,
b=a,
a=x%m;
return d;
}
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~127~~ ~~126~~ 119 bytes
```
class Solution:
def checkRecord(s,n):
a=[1,0,0]
while~n:n-=1;a=[sum(a[:3])]+a;b=a[3]=sum(a[1:7])%(10**9+7)
return b
```
[Try it online!](https://tio.run/##hY1BC8IgGEDP81d4Cfy2FdoOI4d/oo7Dg3PGpKVDHdGlv25FBN16x8eDt9zT5N0@Zz2rGPHJz2uy3nGER3PGejL6cjTah5HE2gFHhRI9q2lNJSpuk53Nw3G3Fax7@bheiep5I0FWqhuE6hspPpLxVsKGMFqWh6oFVAST1uDwkJdgXSLfL4Hd75NRAPSneAOQnw "Python 2 – Try It Online") Somewhat slower than @SurculoseSputum's answer. Edit: Saved 1 byte thanks to @KevinCruijssen. Saved a further 7 bytes thanks to @xnor.
Out of interest, I also wrote a 34-byte solution in [Charcoal](https://github.com/somebody1234/Charcoal):
```
≔Ｅ⁶¬ιηＦＮＵＭη⎇﹪볧η⊖λΣ…η⁺³λＩ﹪Ση⁺⁷Ｘφ³
```
[Try it online!](https://tio.run/##NY7LCsIwEEX3fkWWE4igFHTRVYmbLloK@gMxSU0hj5KH2q@PiehsZjHn3LlcMc8d0zl3ISwPCwNb4UTQ6CIsGBOkcLubnUfQ2zXFMZm79IAxKhx1xjArQBF0k94yv8HgRNIONEFNcbvYWyHfFbhI7qWRNkoBuuZekwG6cS2pcmslJp0CNASVa5l2N/nFRqAsxH9qVRT@keey3at0meuvr5Lz8ZD3T/0B "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔Ｅ⁶¬ιη
```
Create an array of six elements where only the first element is `1` and the others are all `0`.
```
ＦＮ
```
Loop over the given number of times.
```
ＵＭη
```
Modify the array in-place according to the result of the mapping (the mapping is calculated first, then the array modified).
```
⎇﹪λ³
```
For positions 1, 2, 4 and 5:
```
§η⊖λ
```
Take the previous element of the previous array.
```
Σ…η⁺³λ
```
Otherwise take the sum of the array so far plus the next three elements.
This results in `h = [sum(h[0:3]), h[0], h[1], sum(h), h[3], h[4]]`.
```
Ｉ﹪Ση⁺⁷Ｘφ³
```
Take the final sum and reduce modulo `7+1000**3`.
[Answer]
# Java, 137 bytes
```
long checkRecord(int n){long a=1,b=1,c=0,d=1,e=0,f=0,x,y,m=7+(int)1e9;for(;n-->0;y=x+d+e+f,f=e,e=d,c=b,b=a,a=x%m,d=y%m)x=a+b+c;return d;}
```
Figured I'd add a Java answer, since it was missing. It's a straightforward port of [*@ceilingcat*'s C answer](https://codegolf.stackexchange.com/a/206422/52210), since I couldn't find anything shorter.
[Try it online.](https://tio.run/##TU9BasMwELznFXsJSMg28qkUofygl@ZYSllLcqrEkoIspzbGb3e3OXVhGNidGXau@MD6am@7GXAc4Q19XPchxQuYb2du786kbJmPBSJfn3vUbdURjJaVJXbEPWGuliroF/En5q17VX3KTMW6Pkm16FlY4URPSkcOS@6OUrBCPR8D5SzHwGeNohNGZVemHMGqbQe4T93gDYwFC9EjeQuBnmTnkn28fHwC8vUANOdlLC40aSrNnU5liCy6n2cjxpv/bVopv6SUnCsybodt/wU)
---
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~24~~ 23 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
6LΘIFÐÁr3£‚O30Sǝ}O9°7+%
```
[Try it online.](https://tio.run/##ASsA1P9vc2FiaWX//zZMzphJRsOQw4FyM8Kj4oCaTzMwU8edfU85wrA3KyX//zEw)
**Explanation:**
```
6L # Push the list [1,2,3,4,5,6]
Θ # Check == 1 for each (1 if truthy; 0 if falsey): [1,0,0,0,0,0]
IF # Loop the input amount of times:
Ð # Triplicate the list at the top of the stack
Á # Rotate the top list once towards the right: [f,a,b,c,d,e]
r # Reverse the stack so this rotated list is at the bottom
3£ # Pop and push the first three items of the top list: [a,b,c]
‚ # Pair it with the full list: [[a,b,c,d,e,f],[a,b,c]]
O # Sum both inner lists: [a+b+c+d+e+f,a+b+c]
30S # Push [3,0]
ǝ # Insert the a+b+c+d+e+f and a+b+c at indices 3 and 0 respectively in
# the rotated list: [a+b+c,a,b,a+b+c+d+e+f,d,e]
}O # After the loop, sum the resulting list
9° # Push 10 to the power 9: 1000000000
7+ # Add 7: 1000000007
% # Modulo
# (after which the result is output implicitly)
```
[Answer]
# x86\_64 machine language for Linux, 83 bytes
```
0x00: 55 push rbp
0x01: 45 31 C0 xor r8d, r8d
0x04: 31 C9 xor ecx, ecx
0x06: 53 push rbx
0x07: 6A 01 push 1
0x09: 41 5A pop r10
0x0b: 31 DB xor ebx, ebx ; a=b=d=0
0x0d: 4D 89 D1 mov r9, r10
0x10: 4D 89 D3 mov r11, r10 ; c=e=f=1
0x13: BE 07 CA 9A 3B mov esi, 0x3b9aca07 ; m=1000000007
0x18: 4B 8D 04 0B lea rax, [r11 + r9]
0x1c: 48 01 C8 add rax, rcx ; x=a+b+c
0x1f: 48 99 cqo
0x21: 49 8D 0C 02 lea rcx, [r10 + rax]
0x25: 48 F7 FE idiv rsi ; x%=m
0x28: 4C 01 C1 add rcx, r8
0x2b: 48 01 D9 add rcx, rbx ; y=x+d+e+f
0x2e: 4C 89 C3 mov rbx, r8 ; f=e
0x31: 48 89 C8 mov rax, rcx ; e=d
0x34: 4C 89 C9 mov rcx, r9 ; c=b
0x37: 48 89 D5 mov rbp, rdx ; b=a
0x3a: 48 99 cqo
0x3c: 48 F7 FE idiv rsi ; y%=m
0x3f: 4D 89 D0 mov r8, r10
0x42: 4D 89 D9 mov r9, r11
0x45: 49 89 D2 mov r10, rdx ; d=y
0x48: 49 89 EB mov r11, rbp ; a=x
0x4b: FF CF dec edi
0x4d: 75 C9 jne 0x18 ; if( --n ) goto 0x18
0x4f: 92 xchg eax, edx
0x50: 5B pop rbx
0x51: 5D pop rbp
0x52: C3 ret ; return d
```
To [Try it online!](https://tio.run/##hY/PSsQwEMbv@xSlIKTiQtIkNkPxDTx5ziWZSdZl3a50KwTFV7dO6sWTzunj@/ODwf0BcV3FLT4nPD0lvMzUie7hsfUFpVbGWuvLfbAaQStftLLBKMmKlANDFH2JiXTVnEYIGOTgi4zSODKcGodOKuPYQ3YAwJec8mCc7LeUaQZ9YQISVDI61g71lkL1fQF2yDreGvpZbwsiWT3qWQNVck6xal70CIPFzDxtycZ2XM/hOInuY/c6H6cli/aG/NTe/fpcNKrpuvGvQv9fQcl6W2tOy9s8NXLcfa5fmF/C4bru31NJeF0Cnr4B "C (gcc) – Try It Online"), call the following c code as if it were a function (you may also be able to paste it into one or more 'interview preparation websites' and run it as if it were a c program)
```
(*checkRecord)()=L"\xc0314555\x6a53c931\x315a4101\xd1894ddb\xbed3894d\x3b9aca07\x0b048d4b\x48c80148\x0c8d4999\xfef74802\x48c1014c\x894cd901\xc88948c3\x48c9894c\x9948d589\x4dfef748\x894dd089\xd28949d9\xffeb8949\x92c975cf\xc35d5b";
```
] |
Subsets and Splits