text
stringlengths 180
608k
|
|---|
[Question]
[
**This question already has answers here**:
[Sᴍᴀʟʟ Cᴀᴘꜱ Cᴏɴᴠᴇʀᴛᴇʀ](/questions/60443/s%e1%b4%8d%e1%b4%80%ca%9f%ca%9f-c%e1%b4%80%e1%b4%98%ea%9c%b1-c%e1%b4%8f%c9%b4%e1%b4%a0%e1%b4%87%ca%80%e1%b4%9b%e1%b4%87%ca%80)
(22 answers)
Closed 6 years ago.
## Challenge
Your program needs to take an input of a string, where the string has only letters, no special characters, no numbers, and no accents (they look all weird).
Then, your program should output a [superscript](https://en.wikipedia.org/wiki/Subscript_and_superscript) version.
## Example
**Input:** hello world
**Output:** ʰᵉᶫᶫᵒ ʷᵒʳᶫᵈ
## Test Cases
```
hello - ʰᵉᶫᶫᵒ
code - ᶜᵒᵈᵉ
golf - ᵍᵒᶫᶠ
asdf - ᵃˢᵈᶠ
qwerty - ᑫʷᵉʳᵗʸ
abcdefghijklmnopqrstuvwxyz - ᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏᶫᵐᶰᵒᵖᑫʳˢᵗᵘᵛʷˣʸᶻ
```
## Help
If you need help understanding check out this website, it's a translator:
<http://txtn.us/tiny-text>
## Code Golf
This is a code golf, so the shortest code wins!
Good luck!
## Edits
**Edit #1:** There will be no caps, since I just realized they look weird.
[Answer]
# JavaScript (ES6), 10 bytes
```
s=>s.sup()
```
>
> It should be noted that the [`sup()` method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/sup) has been deprecated so this solution may not work in all browsers nor is it guaranteed to continue working in future releases of browsers that do currently support it. Tested and confirmed to work in Chrome v58.
>
>
>
---
## Try it
```
f=
s=>s.sup()
o.innerHTML=(i.value="Hello!")+": "+f(i.value)
oninput=_=>o.innerHTML=i.value+": "+f(i.value)
```
```
*{font-family:arial,sans-serif}
```
```
<input id=i><p id=o>
```
[Answer]
# PHP+HTML, 17 Bytes
```
<sup><?=$_GET[0];
```
[Answer]
# Mathematica, 13 bytes
```
#~Style~Tiny&
```
[Answer]
# Java 8 (AWT / Swing), 79 bytes
```
s->new java.awt.Frame(){{add(new javax.swing.JLabel("<html><sup>"+s));show();}}
```
Unfortunately there is no reliable online compiler available for Java GUI, so no TIO-link.
# Java 8 (Console), ~~123~~ 117 bytes
```
s->{for(int x:s.toCharArray())System.out.print("ᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏᶫᵐᶰᵒᵖᑫʳˢᵗᵘᵛʷˣʸᶻ".charAt(x-97));}
```
[Try it here.](https://tio.run/nexus/java-openjdk#jZC9TsNADMf3PoWV6TI0K4IKJMRMl46I4Xr5aCC9C3eXklBlYgAGxMcASDAgkFi6VKALSLxB@hR@kpCETEwslmz/bf9/ZhFVCnZpyOc9gJBrT/qUeTBsUoCZCF1gZKRlyANQ9qCu5r06KE11yGAIHDahUv2tuS8kqech3VCOFjsTKrelpBmx7VGmtDd1RKKduN6jiYXmFM0ZFk9oztFcYPGM5rJcYvFWvqO5wmKB5hqLJZpbNHd4syg/Vi9o7tE8oHksP1ev5RcW35bDmjOapP31Ndse5FXjL07GUW2tc9gSTGu@DmJvH6j9C8cdRiztKW21XAB/jUacdJ1WyoTrBSLy/ymnY@Z6fjAJDw6jKRfxkVQ6mR2n2YnV/TGvfgA)
[Answer]
# Pyth, 75 bytes (30 chars)
```
XwG"ᵃᵇᶜᵈᵉᶠᵍʰᶦʲᵏᶫᵐᶰᵒᵖᑫʳˢᵗᵘᵛʷˣʸᶻ
```
[Try it!](https://pyth.herokuapp.com/?code=XwG%22%E1%B5%83%E1%B5%87%E1%B6%9C%E1%B5%88%E1%B5%89%E1%B6%A0%E1%B5%8D%CA%B0%E1%B6%A6%CA%B2%E1%B5%8F%E1%B6%AB%E1%B5%90%E1%B6%B0%E1%B5%92%E1%B5%96%E1%91%AB%CA%B3%CB%A2%E1%B5%97%E1%B5%98%E1%B5%9B%CA%B7%CB%A3%CA%B8%E1%B6%BB&input=hello%2C+world%21&debug=0)
] |
[Question]
[
# Challenge
Detect the newest file in a specific folder and pass it as an argument to another process. The first argument to your program will be the folder, and the second argument will be the full path to the process.
Please specify the platform(s) your code works on.
# Examples
## Windows
```
newestfile "C:\Public_domain_movies\" "C:\Mplayer\mplayer.exe"
```
## Linux
```
./newestfile /home/user /bin/ls
```
[Answer]
# Zsh - 15
Only tested on Linux, but it should work on other platforms too.
```
$2 $1/*(.om[1])
```
[Answer]
## Windows, PowerShell, 35
```
&$args[1](ls $args[0]|sort *w*)[-1]
```
[Answer]
## Linux, Ruby, 52 characters
```
exec$*[1],Dir[$*[0]+"/*"].sort_by{|a|test(?M,a)}[-1]
```
I'm not sure if I undestood the specifications correctly, so if this doesn't work as intended, please let me know. I only tested this on Linux, but *in theory* it should run on Windows, too.
[Answer]
## linux - bash+sed - 18 bytes
```
$2 `ls -t $1|sed q`
```
Does not work if the arguments contain blanks.
[Answer]
## Windows, cmd, 54
```
for /f "delims=" %%A in ('dir/b/o-d %1')do %2 %%A&exit
```
Caveats:
* Closes the current shell session
* Will consider directories (as do most other solutions)
] |
[Question]
[
**This question already has answers here**:
[Write an aphorism using valid code [closed]](/questions/18093/write-an-aphorism-using-valid-code)
(49 answers)
Closed 9 years ago.
I am looking for either suggestions or examples of more famous sayings written in code! If you have a website or database of them, please link that below your favorite one!
Examples:
```
while(!(succeed = try()))
if(lifegivesyou == lemons) {makelemonade();)
```
[Answer]
How about:
```
~wish&~want;
```
or
```
Penny.Earned = Penny.Save();
```
[Answer]
# bash
```
say "It's going to be legen..."
waitforit
say "dary!"
```
[Answer]
```
if (glass.getLevel() == 0.5)
throw new ContainerTooLargeException(glass + " is twice as big as it needs to be.");
```
[Answer]
# C++
```
Toast toast = New Toast();
toast.fillside("butter", "up");
toast.fall(); //this method swaps sides, now buttered side is down
```
] |
[Question]
[
**If a game can result in a win, worth one point; a draw, worth half a point; or a loss, worth no points; how many ways are there of scoring `k` points in `n` games?**
Applicable scenarios include NFL and chess.
* Input is via stdin, and consists of `n` and `k` on separate lines.
* `n` will be a non-negative integer. `(n ≤ 16)`
* `k` will be either a non-negative integer or a non-negative integer plus a half. `(k ≤ n)`
* Output is to stdout. It may, but does not have to, include a trailing newline.
### Test cases
In each case, the first two lines are user-supplied input and the third line is the program output.
```
10
4.5
8350
16
8
5196627
16
13.5
13328
12
12
1
```
[Answer]
## Perl 59 bytes
```
@0=map"$v"+($v=$u)+($u=$_),@0,0,0for(@0=1)x<>;print@0[<>*2]
```
Iteratively generates each row of the triangle of trinomial coefficients up to *n*, and then prints the correct term, *2k*.
---
## Ruby 73 bytes
```
r=*1
gets.to_i.times{r<<0<<u=v=0;r.map!{|t|v+(v=u)+u=t}}
p r[gets.to_f*2]
```
Largely equivalent to the Perl solution above.
---
## Python 84 bytes
```
r=[1]
exec"r=map(sum,zip(r+[0],[0]+r,[0,0]+r))+[1];"*input()
print r[int(input()*2)]
```
Same method as both solutions above.
---
## PHP 91 bytes
```
<?for($n=+fgets(STDIN);(${$j--}+=$$j+${$j-1})?:$n--*$j=$i+=2;${0}=1);echo${fgets(STDIN)*2};
```
Despite being the longest, this was actually the most fun to work on.
[Answer]
## R - 81
```
cat(sum(rowSums(do.call(expand.grid,replicate(scan(n=1),0:2,s=F)))==2*scan(n=1)))
```
A bit longer (106) but I also enjoyed writing it as a recursion:
```
Z=function(n,k)if(n<1|k<0)0 else if(n<2&k<3)1 else Z(n-1,k)+Z(n-1,k-1)+Z(n-1,k-2);Z(scan(n=1),2*scan(n=1))
```
[Answer]
## C# (189 bytes)
Collaborative results from @glthomas, @recursive, @PeterTaylor and @primo
**Best Solution (189 Bytes)**
@glthomas and @recursive each found an additional 2 Bytes over the weekend. (We're convinced that this is the optimal solution using .Net 4.0 and compiling in VS 2010)!
```
using S=System.Console;class C{static void Main(){S.Write(G(G(),2*G()));}
static float G(float L=-1,float T=1){return L<0?float.Parse(S.ReadLine())
:T==0?1:--L<0?0:G(L,T)+G(L,T-1)+G(L,T-2);}}
```
**Improved Solution (193 Bytes)**
```
using System;class C{static void Main(){Func<float,float,float>W=null;W=(n,k)=>n<0?
k*float.Parse(Console.ReadLine()):k==0?1:--n<0?0:W(n,k)+W(n,k-1)+W(n,k-2);
Console.Write(W(W(-1,1),W(-1,2)));}}
```
The additional Byte was saved by combining the input acquisition and static recursive method into a single multipurpose `Func<>`. Input acquisition is triggered when we pass in a negative value of `n`
**Original Solution (195, 194)**
```
using K=System.Console;class C{static void Main(){K.Write(T(int.Parse(K.ReadLine
()),2*float.Parse(K.ReadLine())));}static float T(int n,float k){return k==1?1:--
n<0?0:T(n,k)+T(n,k-1)+T(n,k-2);}}
```
[Answer]
## C# (210 209 chars)
More efficient: iterative approach (209 chars):
```
using K=System.Console;class C{static void Main(){int
n=int.Parse(K.ReadLine()),k=(int)(2*float.Parse(K.ReadLine())),j;var t=new
int[k+3];for(t[2]=1;n-->0;)for(j=k+2;j>1;)t[j]+=t[--j]+t[j-1];K.Write(t[k+2]);}}
```
Less efficient: recursive approach (210 chars);
```
using K=System.Console;class C{static void Main(){int
n=int.Parse(K.ReadLine()),k=(int)(2*float.Parse(K.ReadLine()));K.Write(T(n,k));}static
int T(int n,int k){return k<1?k+1:--n<0?0:T(n,k)+T(n,k-1)+T(n,k-2);}}
```
Note that if `k` is non-integral, it should be supplied in a format applicable to the locale. In my case that means that I have to format the input using `,` as the decimal separator.
[Answer]
## GolfScript (39 chars)
```
'.'/(~2*@,+[1]@{[0.@0+{@2$2$++@@}/+]}*=
```
[Online demo](http://golfscript.apphb.com/?c=OycxMAo0LjUnCgonLicvKH4yKkAsK1sxXUB7WzAuQDAre0AyJDIkKytAQH0vK119Kj0%3D)
Based on my [answer](/a/3822/194) to a [previous question](/q/3815/194) about *binomial* coefficients.
[Answer]
## APL (22)
```
+/(2×⎕)=+⌿(N⍴3)⊤⍳3*N←⎕
```
It's not exactly efficient though (set your workspace size to a couple of gigabytes if you want it to actually work up to N=16).
] |
[Question]
[
### The challenge:
Write a program or function in any language that takes as an argument (command-line or function) a single English word. It returns or outputs the pluralized form of the word.
(To clarify, the program or function will be executed many times on different words, but separately - the list of words won't be passed all at once.)
### The scoring:
The score of a program or function is `-(characters in program + 1) * number of wrong answers`. Highest score wins. Joke answers will likely lose by a huge margin (I'm planning on putting in maybe 1,000 words) and if you're amazing you get the highest score of 0.
### Example test data:
```
woman
turn
fly
court
finger
blitz
pie
injury
vertex
alleyway
alloy
ox
goose
mouse
house
louse
waffle
right
bacterium
virus
cherub
chaetognath
boy
man
shaman
figure
prefix
etc.
```
Those are just some that I picked off the top of my head. The real test cases will have even stranger plurals, but the distribution between types of suffixes will be more even.
Enjoy!
### Additional Rule
No Mathematica. Sorry.
[Answer]
## sed, 6 chars
Someone should give this a try...
```
s/$/s/
```
Invoked with `sed -f myscript.sed < words.txt > output.txt`
I can afford 22 times more mistakes, compared to Gordon Bailey's solution, and still win.
With the sample input I do win, because he misses "mice" and "lice" (and maybe more, there are some I need to look up), and this sample is too short for me to have 44 mistakes...
[Answer]
```
require 'open-uri'
def p(w)
open("http://en.wiktionary.org/wiki/#{w}"){|f| f.read}.match(/plural-form-of.*?title=\"(.*?)\"/)[1]
end
```
ruby at 135. It got all of the sample input (though it will eventually begin returning 403s if you type quickly enough).
[Answer]
## sed - 155 (not including #! line)
```
#!/bin/sed -Ef
s/man$/men!/
s/([aeiou](x|z))$/\1es!/
s/ium$/ia!/
s/([^!aeiou])y$/\1ies!/
s/((r|gh|l|s)[^!aeiou])$/\1s!/
s/([^!aeiou]{2}|.s)$/\1es!/
s/([^!])$/\1s/
s/!$//
```
This will read from stdin, and I think it will do an okay job for most input. The basic idea is that it tries each regex line by line. Whenever it matches it makes a replacement that appends `!` to make sure that no other regexes will match, then it drops the `!` on the last line.
I tried to deal with most special cases, but it will definitely fail on some (goose and mouse for example)
Sample invocation:
```
chmod a+x GordonBailey.sed
echo $word | ./GordonBailey.sed
```
[Answer]
```
perl -mLingua::EN::Inflect=PL -pe's/.*/PL$&/e'
```
[Answer]
# [Extended BrainFuck](http://sylwester.no/ebf/): 9
```
,[.,]||s|
```
Compiling:
```
beef ebf.bf < plural.ebf > plural.bf
```
Turns into the following [BrainFuck](http://en.wikipedia.org/wiki/Brainfuck) code: (39)
```
,[.,]>++++++++++[-<+++++++++++>]<+++++.
```
Sample invocation:
```
$ echo -n test | beef plural.bf
```
Any BrainFuck interpreter can be used instead of beef. It takes one word in stdin and ends it with *EOF*. Alternatively you can use `echo test | bf -n plural.bf` where in this particular interpreter`-n` assumes *EOF* on first linefeed.
] |
[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/237585/edit).
Closed 2 years ago.
[Improve this question](/posts/237585/edit)
# Task :
Wonky numbers are 3-or-more digit numbers that meet one or more of the following criteria:
* Any digit followed by all zeros: `100`, `70000`
* Same digit throughout the entirety of the number : `1111`, `777777777`
* The digits are in consecutive ascending order : `1234`, `1234567890` (for 0 see below)
* The digits are in consecutive descending order : `4321`, `9876543210`
* The number is a palindromic number : `1221`, `123321`
Ascending and descending order mean no repeated digits in their so `122` is not ascending in this case, you may also not skip digits `1245` is not Wonky because 3 is missing. For both ascending and descending numbers 0 will come last so order is : `1234567890` and `9876543210` for ascending and descending respectively. Numbers can be given in any order, do not assume that it may be in some specific order : `1234`, `987`, `76842` are all valid numbers.
# I / O :
Your input will always be a number (positive) in the following range : $$99 < Z < 1,000,000,000$$
Check if the number is a Wonky number.
You may not take input as anything but a number unless your language is simply incapable of handling that, in which case take input in any reasonable format (per language)
You may output any truthy value (for wonky numbers) and any falsy value (for non wonky numbers).
# Examples :
```
Input : Output
100 : true
12344321 : true
77777777777 : true
132 : false
321 : true
122 : false
987789 : true
98765 : true
120000 : false
100001 : true
786 : false
890 : true
```
# Extra Credit :
Check if number is not a Wonky number, but one of next `x` numbers is a wonky number, where x is in range of 1 (inclusive) to 10 (exclusive).
This is code-golf, so shortest code in bytes wins.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~103~~ ~~88~~ 82 bytes
```
n=>"1234567890|9876543210".match(n)|/^(.0+|(.?)(.?)(.?)(.?).?\5\4\3\2\1)$/.test(n)
```
[Try it online!](https://tio.run/##bZBNboMwEIX3PcUk6sJWqbHN/8Kw6ikwlRwCTSKCK3C74u50aNUKQUeyF5/fvJnnm/k0Yz1c391zb8/N3Kq5V/lRyCCM4iTN@JSlSRyFgRT8yO7G1RfS08l/JYw/TYQVdH1YoSMd6kBLLeijz1wzOpTPHSgo4QHwEpx7AG74aKDyfgjOWvxhw5Pf2j6IQC6oNd34x/7pF3IvwzAYaqv8jrhv51g7B7HQ/a5pvFIiqlhrhxeDv0VK48GpoqByqG0/2q5hnX0jh0NLDFIFJ0rnLw "JavaScript (Node.js) – Try It Online")
* -15 bytes thanks to Dom Hastings.
* -6 bytes thanks to Kevin Cruikssen.
# Original :
# [JavaScript (Node.js)](https://nodejs.org), 103 bytes
```
n=>RegExp(n).test("1234567890|9876543210")|/^(\d0+|(\d)\1+|(\d?)(\d?)(\d?)(\d?)\d?\6\5\4\3\2)$/.test(n)
```
[Try it online!](https://tio.run/##bY9NbsIwEIX3PcWAuvCoabCdXxaGFRdgi1PJBIe2imyUpFUXuXuYgKiqpCP5Wfr8Zsbv03ybtmw@Lt2r8yc7VGpwarO3593PhTkMO9t2bClkFCdplq95v86zNIkjKfgS@9Ub0yf@0pOiFrd7ixOho1Od6FhHWuLz6j7S4VCDggM8AYngPADomi8LRXAntHHcAhOePWr6ICI5osrU7S/7p1/IuY0iUbSp8xZ03s6pZhPESOd/zdM/TkJFWPlmZ8p3xg4mgGOBoDZQetf62oa1P7PFomKGqIIj4nAF "JavaScript (Node.js) – Try It Online")
# Changes :
* changed all `\d` to `.` because input is guaranteed to be a number.
* instead of `regex(n).test` switch to match
* Removed the check for same digits (because palindromes check that)
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 43 bytes
```
$
¶$^$`¶10*#0
Y`#`d
\b(.+)¶(.+¶)?.*\1|¶0*.¶
```
[Try it online!](https://tio.run/##K0otycxLNPyvquGe8F@F69A2lTiVhEPbDA20lA24IhOUE1K4YpI09LQ1D20Dkoe2adrracUY1hzaZqCld2jb//@GBgZchkbGJibGRoZc5gjAZWhsxAUSMzQy4rK0MDe3sARRZqZAAQOQHiBhANRhYQYA "Retina – Try It Online") Link includes test cases. Explanation:
```
$
¶$^$`¶10*#0
Y`#`d
```
Append the reverse of the input and build up the string `01234567890`.
```
\b(.+)¶(.+¶)?.*\1|¶0*.¶
```
Check whether either the string or its reverse is a substring of each other (i.e. palindromic) or the created string, or whether the reverse is all zeros except the last digit.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~19~~ ~~18~~ ~~16~~ 15 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
RT‹žhĆI‚åàIÂQM
```
[Try it online](https://tio.run/##ASUA2v9vc2FiaWX//1JU4oC5xb5oxIZJw4LigJrDpcOgw4JRTf//ODkw) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeX/oJBHDTuP7ss40lZ5uOlRw6zDSw8vALICff/raMb8jzY0MNAxNwACHUMg0DGHAR1DI2MTMGFqZm5haaBjYmxkqGNpYW5mCmIBlRsB@UB5YwhlApY3RwAdqHqgZog2HUOQNWDFIC2WQFkdoLkgsxUUDI2NQCYCMdgt5hZmOobGQC2mQDUgxSBlIOVAk2IB).
**Explanation:**
```
RT‹ # Rule 1:
R # Reverse the (implicit) input
T‹ # Check if it's smaller than 10
žhĆI‚åà # Rules 3 & 4:
žh # Push builtin 0123456789
Ć # Enclose, append its own head: 01234567890
I # Push the input-integer again
 # Bifurcate it (short for Duplicate & Reverse copy)
‚ # Pair them together
å # Check for both whether it's a substring of 01234567890
à # Pop and push the maximum to check if either was truthy
IÂQ # Rules 2 & 5:
I # Push the input-integer yet again
 # Bifurcate it (short for Duplicate & Reverse copy)
Q # Check if both are equal, thus it's a palindrome
# (if all digits are the same it's also a palindrome, so no need to
# check rule 2 separately)
M # Push the largest number on the stack to check if any were truthy
# (which is output implicitly as result)
```
[Answer]
**Broken because I didn't notice the “0 comes last” rule. I'll try to fix it.**
# [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ ~~19~~ 12 bytes
```
DµIṠEoŒḂ*ḊẸ$
```
[Try it online!](https://tio.run/##y0rNyan8/9/l0FbPhzsXuOYfnfRwR5PWwx1dD3ftUPl/uP1R05r//6O5DA0MdLgMjYxNTIyNDHW4zBEAKGxspMMFFjY0ArIsLczNLSzBtJkpSMzAAKwZRIG0WpjpcMUCAA "Jelly – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 18 bytes
```
Ḣ0J≈?¯ȧ:19∩⊍¬?Ḃ⁼Wa
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%E1%B8%A20J%E2%89%88%3F%C2%AF%C8%A7%3A19%E2%88%A9%E2%8A%8D%C2%AC%3F%E1%B8%82%E2%81%BCWa&inputs=1234567890&header=&footer=)
`0` can still go frick itself.
## Explained
```
Ḣ0J≈?¯ȧ:19∩⊍¬?Ḃ⁼Wa
Ḣ0J≈ # Test 1: Is the input[1:] all 0's? (not why I hate 0 btw)
?¯ȧ:19∩⊍¬ # Test 2: Is the differences between all numbers either 1 or 9? (this is why I hate 0)
?Ḃ⁼ # Test 3: Is the input a palindrome?
Wa # Did any of the tests pass? For some reason the -G flag doesn't work here to save 2 bytes. /shrug
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 27 bytes
```
Ｎθ≔⁺⭆χι⁰η∨‹⮌θχ⊙⟦η⮌η⮌Ｉθ⟧№ιＩθ
```
[Try it online!](https://tio.run/##RYzNCsIwEITvPsUeNxAhOfdUehL8KXosPcQSmkBMazYp@PRxBcWBhWHm25mcSdNiQq2HuJZ8Lo@7TfgUza4l8nPEPhTCW04@ziezolYSvJCg@BxTPRcZLwmPlgivdrOJLP9L0B@kjS8cnIRf4cTfd4Yyk2KU0C2FVzybb8Zqah20UmPdb@EN "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` for wonky, nothing if not. Would have saved 4 bytes if it wasn't necessary to take input as a number. Explanation:
```
Ｎθ
```
Input the number.
```
≔⁺⭆χι⁰η
```
Get the string `01234567890`.
```
∨‹⮌θχ
```
Output `-` if the reverse of the number is less than 10, or...
```
⊙⟦η⮌η⮌Ｉθ⟧№ιＩθ
```
... any of the strings `01234567890`, `09876543210` or the reverse of the number as a string contain the number as a string.
] |
[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/230999/edit).
Closed 2 years ago.
[Improve this question](/posts/230999/edit)
Imagine you are sitting at a park. Suddenly your car gets hijacked and being driven in different directions. Here are the directions, arrows show which direction goes towards where:
```
South
|
V
East-> <-West
^
|
North
```
After being driven, the car stops. Now you have to find out how far the car is away from you and angle of you and your car in degrees. It will be given how many units have been driven and in which direction. Input/Output format is flexible, you can take a 2D list/1D list/string etc and return the displacement and angle.
**Test Cases**
```
[[40,East],[40,North],[30,West],[30,South]] -> 14.1421356237 45.0
[[45,North],[200,East]] -> 205.0 75.9637565321
```
No need to output exact angle and distance, just 2 digits after decimal is fine, but more than 2 is fine too.
Only given directions are North, east, south, west.
The value of movement in a direction is always positive integer.
Trailing Whitespace allowed. Code golf, so shortest code wins.
*My English is bad, sorry. Please ask for clarification if you have trouble understand ing*
[Answer]
# [Ruby](https://www.ruby-lang.org/), 44 bytes
```
->l{z=l.sum{|a,b|a*b};[z.abs,z.arg*57.2958]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6nuso2R6@4NLe6JlEnqSZRK6nWOrpKLzGpWAdIFqVrmZrrGVmaWsTW/i9QSIuOjjYx0DGM1QFTmUDa2EBH1xBGZ8bGxnJBlZmClRkZgNXFxv4HAA "Ruby – Try It Online")
Input direction as:
* 1i East
* 1 North
* -1i West
* -1 South
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 18 bytes
Anonymous tacit infix function, taking a list of complex units as one argument and the magnitudes as another argument.
```
(|,{180÷○÷12○⍵})+.×
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///X6NGp9rQwuDw9kfTuw9vNzQCUo96t9Zqauv/T3vUNuFRb9@jruZHvWse9W45tN74UdvER31Tg4OcgWSIh2fw/zQFEwMvAwUDLxMDBaA8hA1icKWBBE0VjAyAYgA "APL (Dyalog Unicode) – Try It Online")
`+.×` dot product, i.e. sum of products of directions and magnitudes
`(`…`)` apply the following tacit function to that:
`{`…`}` apply the following lambda to that; `⍵` is the argument:
`12○⍵` the phase (i.e. angle)
`÷` reciprocal of that
`○` *π* times that
`180÷` 180 divided by that
`|,` prepend the absolute value
---
If we were allowed to answer in radians, the solution would be just:
```
10 12○+.×
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///39BAwdDo0fRubb3D0/@nPWqb8Ki371FX86PeNY96txxab/yobeKjvqnBQc5AMsTDM/i/iYECEBmDUZqCoZeBgoGXocKh9RAWkOYyMVUwMgBJgiSAwgA "APL (Dyalog Unicode) – Try It Online")
`+.×` dot product, i.e. sum of products of directions and magnitudes
`10 12○` magnitude and phase of that
[Answer]
# [Python 3](https://docs.python.org/3/), 77 bytes
```
lambda a:(abs(v:=(sum(x*d for x,d in a))),phase(v)*180/pi)
from cmath import*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NcxNCoJAGMbxfad4270jIym1EMEjeAJz8ZoOjjgfjKPYWdoIUVfoLN4mSVr9Fs_D__G2d98avTxFdn2NXoTJmvekqpqAUqRqwCnNcBgVzkENwjiYeQ1SAzHGuG1paHBiQZxEJyvZQTij4KbItyCVNc4He_RjndQeBTYT9Si1HT1uAbavy3osikvE45L_6DbPEQ_jv11Z7s8v)
Takes the direction as a complex number: `1`, `-1`, `1j`, or `-1j` for east, west, north, and south respectively.
---
# [Python 2](https://docs.python.org/2/), 74 bytes
Thanks to @xnor
```
from cmath import*
m,t=polar(sum(x*d for x,d in input()))
print m,t*180/pi
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728oLIkIz_PaMGCpaUlaboWN73SivJzFZJzE0syFDJzC_KLSrS4cnVKbAvycxKLNIpLczUqtFIU0vKLFCp0UhQy84CooLREQ1NTk6ugKDOvRAGoWMvQwkC_IBNiItTgBTcVo6NNDHQMY3XAVBaQNjbQ0TWE0VmxsRCVAA)
Full program taking input as a list from STDIN with directions as above.
[Answer]
# [Python 2](https://docs.python.org/2/), 115 bytes
```
x=y=0;from math import*
for u,d in input():exec('x+=u y+=u x-=u y-=u'.split()[d])
print hypot(x,y),atan(x/y)*180/pi
```
[Try it online!](https://tio.run/##JYrBCsMgEAXv@Yq9RVPbmKSH0pIvCR5Ck6BQdbEr6NdbQ@ExM4eHmbR3YylpzrN8HcFbsCtpMBZ9oK45fIAoNjCuDiMx/tzT/mZtuswR8ol0PauivX3xY@pl2RRvMBhHoDN6YklkLlZaHUt95t3wkD2aUpblLoVU4tRQNUkx/jUp9QM "Python 2 – Try It Online")
Straightforward approach. Full program. Takes input as a 2D list, 0 for East, 1 for North, 2 for West, 3 for South.
] |
[Question]
[
# Story
There is a woman, named Sarah, whom likes smooth horse rides. She's going to go for a ride down a path too thin to pass any other horses she may come across - and so that her ride can be as smooth as possible she does not want to have to change speed though she would prefer to get to her destination as fast as possible.
# Situational Definition
There is a random number of horses traveling at a random speed which are at a random point between the start and end of the path when the Sarah departs. You must calculate the fastest speed at which she can travel without reaching another of the horses have having to slow her speed.
All horses on this path will slow to the speed of the horse in front of it if it reaches that horses position. It's a popular trail, and there is always at least 1 horse.
Example "starting" point graphic:
[](https://i.stack.imgur.com/pe9d1.png)
Example "half way" graphic:
[](https://i.stack.imgur.com/D7wRL.png)
# Primary Success Criteria
Each post must have a code golf answer - in which you try to solve the problem in as few characters as possible.
I'm open to changes on these policies but I thought it would be interesting if I were allowed to have the following **special rules**: (If they are deemed unfair or flawed I'll certainly reconsider)
* Line endings are assumed to be '\n' not '\r\n' and are only counted as 1 character. This may allow slightly more readable code in some languages.
* To encourage answering in languages that would not usually be "winners" in code golf I'd like to institute a point modification system:
+ Code golf languages have their character count multiplied by 1.25. (I will consider any language in which at least 80% of it's operators or keywords are 1 or 2 characters to be a code golf language.)
+ Answers using compiled strictly typed languages (C, Java, etc) can have their character count multiplied by 0.85 (Because usually it requires more characters to code things in those languages.) Languages like Javascript that may be "compiled" by something like V8 do not count and are loosely typed.
(These may be modifiers may be altered or changed slightly if they are unfair or need improvement)
**Implementation technical details**
You are not required to post surrounding code that is not specific to this problem and is required by your language for your code to execute. For example, in java your code would need a "class" and a main function to execute; however, you can simply provide code as if it were within the "main" function. Any import statements for standard libraries that are required for your code to run should be provided in a code block below your main code, and these will not count towards your character count. You shouldn't use any libraries someone who can compile or execute that language wouldn't have out of the box.
**Code Scope**
Your code should work assuming that variables "d" and "h" (or a closest variant in your language if for some reason those are not acceptable) are present in your scope.
"d" is a number with decimal precision (ex. double/float) representing the distance to the destination from 0.
"h" is an array or list of some structure that can support two values "p" and "s" which are also decimals.
**Testing code**
You should provide a some lines for testing in a code block below your answer code block that assigns d to a random value between or equal to 200 and 1000, and "h" to a list of length between or equal to 10 and 40 in which each list item stores a value for position between 0 and the value of d, and speed is between or equal to 5 and 10. (Not Sarah's horse is the worlds fastest horse and can travel as fast as is optimal, even if that speed greatly exceeds 10)
**Results**
Your answer should store the speed Sarah should travel in a variable capable of storing decimal values such that it could be used in lines below your code for any purpose including answer checking, logging to a console, or outputting in the programs UI. This variable should be named "o" if possible which is short for "optimal speed".
To recap your answer should:
1. Have a code block which outputs the speed assuming "d" and "h" are present in the scope.
2. Have a code block below which assigns "d" and "h" to appropriate values for distance and a list of horses.
3. Output the correct value for "o" which is the speed to travel.
(Again if these variable names are not acceptable in your language please just note why and what variable names you used in place of the ones provided)
The answer with the shortest character count wins.
## Example situation:
"d" is 250, and "h" has one item with "p" of 50 and speed of "20". In this simple case Sarah can travel at 250/((250-50)/20)=25. So "o" should be 25 in this case.
You should be-able to handle cases in which there are numerous horses slowing after reaching the horse(s) in front of them.
## Secondary Objective
If your answer is written in JavaScript and works with the data provided or you provide an additional conforming JavaScript answer in the same post, I will execute your code in something like this in a web page I will later create in the latest version of the chrome browser:
```
var horse = (pos, speed) => ({pos: pos, speed: speed})
var rhorse = (d) => horse(rand(d), rand(5)+1)
var rand = (i) => Math.random()*i
var irand = (i) => Math.round(Math.random()*i)
var answers = []
answers.push(function(d, h){
//YOUR CODE
})
function checkAnswer(ans, d, h){
// Code that which is proven to answer the question reliably
}
var speeds = []
for (var a = 0; a < answers.length; a++) {
var totalTime = 0
for (var i = 0; i < 1000; i++) {
var d = rand(800)+200
var numhorses = irand(30)+10
var h = []
for (var i = 0; i < numhorses; i++)
horses.push(rhorse(d))
var start = performance.now()
answers[a]()
totalTime += performance.now()-start
if (!checkAnswer(ans)
}
var time = (totalTime/1000)
speeds.push({time: time, answer: a})
console.log("Answer " + a + " completed with an average speed of " + time)
}
//Todo: sort by time
console.log(speeds)
```
And then the times I got for each answer will be posted. This does **not** determine the **winner** or the question I will mark as the "answer". It is merely another metric that is being measured. (And if you have interest in trying to out-perform other code examples you can compete that way as well). As mentioned you may provide a second code blog to be used to for the performance comparison.
# Example answer (That would fail)
"
**62 Characters**
```
someHorse = h[0]
o = (d-someHorse.p)/someHorse.s
o = d/o
```
**Test code:**
```
var horse = (p, s) => ({p: p, s: s})
var rhorse = (d) => horse(rand(d), rand(5)+1)
var rand = (i) => Math.random()*i
var irand = (i) => Math.round(Math.random()*i)
var d = rand(800)+200
var numhorses = irand(30)+10
var h = []
for (var i = 0; i < numhorses; i++)
horses.push(rhorse(d))
```
"
You can just note you'll use my test code here if you're code is written in javascript.
# Results:
1. ppperry (By the way, where is he?)- 31 characters
# Disclaimer
This is my first code golf question. I'm willing to fix flaws, please go easy with me.
This question was very strongly inspired by: <https://code.google.com/codejam/contest/8294486/dashboard>
[Answer]
# APL (Dyalog Classic), ~~[10](https://tio.run/##SyzI0U2pTMzJT/@f8qhtgqGBgQFXMZhhD2RzFUCYlpaWXI862hXS/qcc3v6op0O/GEj1rkjRLfgPFP6fxlXMVQAA)~~ 9 bytes
```
⌊/s÷1-p÷d
```
Taking `s`, `p` and `d` as per the specs, respectively horse speeds, positions and the total distance to be travelled.
Explanation:
```
p÷d ⍝ Divide each horse position by the total distance
1- ⍝ and do 1 minus that.
s÷ ⍝ Divide each speed s by each element in the list.
⌊/ ⍝ Finally go over the list accumulating the minimum.
```
You can [try it online](https://tio.run/##SyzI0U2pTMzJT/@f8qhtgqGBgQFXMZhhD2RzFUCYlpaWXI862hXS/j/q6dIvPrzdULfg8PaU/0Cx/2lcxVwFAA)!
Previous 10 byte solution:
```
d÷⌈/s÷⍨d-p
```
Explanation:
```
d-p ⍝ Find the distance each horse still has to travel
s÷⍨ ⍝ and divide it by each horse's speed.
⌈/ ⍝ Now go over the list, accumulating the maximum.
d÷ ⍝ Finally divide the distance by that time.
```
You can [try it online](https://tio.run/##SyzI0U2pTMzJT/@f8qhtgqGBgQFXMZhhD2RzFUCYlpaWXI862hXS/qcc3v6op0O/GEj1rkjRLfgPFP6fxlXMVQAA)!
Thanks to @Grimmy for spotting a (now corrected) problem with my original answer and for saving me 1 byte.
[Answer]
# Python 3, 31 bytes
```
o=d/max((d-x.p)/x.s for x in h)
```
This challenge is actually much simpler than it seems. In order to avoid running in to other horses, you have to arrive at the end after whichever horse (not counting Sarah's) arrives at the end last. To go fastest, it is thus best to arrive at exactly the same time as that horse does.
Testing code:
```
import random
d=random.uniform(200, 1000)
h=[]
class Horse:__slots__=("p", "s")
for _ in range(random.randint(10, 40)):
h.append(Horse())
h[-1].p = random.uniform(0, d)
h[-1].s = random.uniform(5, 10)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
/1α/ß
```
[Try it online!](https://tio.run/##yy9OTMpM/a@UomCroGRvFPKoYdbFJq2jO86ttD20kkupACwcYmIAFAcJ@pzbemidjc@5lbW2XErFYEmXc1tNQ6DStbZF//UNz23UPzz/v1I@WFrn/39d3bx83ZzEqkoA "05AB1E – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 16 bytes \* 1.25 = 20 bytes
```
=ZcdeS.ec-dhbebH
```
Most of this is dedicated to preserving the input format.
Used `H` instead of `h` because `h` isn't a variable in Pyth
While I could've taken that o isn't a variable as an excuse to use `J` or `K` and save a byte, in the end I decided to use `Z` (zerO) because it's what I would've had to do if `o` was available.
[Try it online!](https://tio.run/##K6gsyfhv6xGtY2qgYGSgaZtiZGrw3zYqOSU1WC81WTclIyk1yeP//3/5BSWZ@XnF/3VTAA "Pyth – 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/209149/edit).
Closed 3 years ago.
[Improve this question](/posts/209149/edit)
I was doing the bandit wargame from [overthewire.org](https://www.overthewire.org) and [because I am a script kiddie, I googled the answer for level 24.](https://medium.com/@lukmandenny/overthewire-wargames-bandit-walkthrough-0-34-3c6a52c5e436#2265)
```
password="UoMYTrfrBFHyQXmg6gzctqAwOmw1IohZ"
for i in {0000..9999}
//looping to try any possible pin code
do
echo $password' '$i >> wordlist.txt
//save password and possible pin code into wordlist
done
```
I saw the bash script, and thought, "Well I couldn't have done that because I'm not good at bash." but then I realized that this problem could be done in other languages.
The challenge is simple.
1. Pipe the password in from stdin.
2. Append a space in-between the password and the pin or output it separately
3. Output all PIN combinations. Make sure that there are 4 digits outputted.
4. BONUS flush the output after each line. This is done automatically with `std::endl`.
I went ahead and did it in C++
```
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
string key; //1
getline(cin, key); //I heard that std::getline is
//only standard for linux, so for practical
//purposes use cin.getline(char*,size)
for(int i = 0; i < 10000; i++){ //3
cout << key << setfill('0') << ' ' //2
<< setw(4) << i << endl; //4
}
return 0;
}
```
Obviously it can do better than 301 bytes, but you get the gist.
Also any language is acceptable as long as it can produce the same formatted strings separated by new lines or line breaks.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~9~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
žh4。»
```
[Try it online.](https://tio.run/##yy9OTMpM/f//6L4Mk8OLHzWtedQw69Du//9D830jQ4rSipzcPCoDI3LTzdKrkksKHcv9c8sNPfMzogA)
**Explanation:**
```
žh # Push builtin string "0123456789"
4ã # Get the cartesian product of 4: ["0000","0001",...,"9998","9999"]
€ # Map each string to:
‚ # Pair it with the (implicit) input-string
» # Join each inner list by spaces, and then all strings by newlines
# (after which the result is output implicitly)
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 15 bytes
```
Ｅ×χφ⁺⁺θ ⭆◧Ｉι⁴Σλ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUAjJDM3tVjD0EBHwdDAwEBTRyEgp7RYA0wU6igoKSgBhYJLgMrTQaoDElN8UtNKNJwTi0s0MoFSJiDp0lyNHE0QsP7/PzTfNzKkKO2/blkOAA "Charcoal – Try It Online") Link is to verbose version of code. Test case uses shortened password to avoid TIO output limit. Explanation:
```
×χφ Multiply predefined variables 10 with 1000
Ｅ Map over implicit range
ι Current index
Ｉ Cast to string
◧ ⁴ Left-pad to width literal `4`
⭆ Σλ Convert non-digits to zeros
⁺⁺θ Concatenate with the password and a space
Implicitly output each entry on its own line
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 12 bytes
```
V^jkUT4++QdN
```
[Try it online!](https://tio.run/##K6gsyfj/PywuKzs0xERbOzDF7/9/pdB838iQorQiJzePysCI3HSz9KrkkkLHcv/cckPP/IwopX/5BSWZ@XnF/3VTAA "Pyth – Try It Online")
## Explanation
```
V^jkUT4++QdN
V : For n in
^ 4 : repeated cartesian product 4 times of
jkUT : "0123456789"
++QdN : output input + ' ' + n
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 33 bytes
```
@(a)fprintf([a,' %04u\n'],0:9999)
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999BI1EzraAoM68kTSM6UUddQdXApDQmTz1Wx8DKEgg0/6dpqJekFpeoa/4HAA "Octave – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 32 bytes
```
10000.times{|i|puts$_+" %04i"%i}
```
Suggested by Dingus.
[Try it online!](https://tio.run/##KypNqvz/39AACPRKMnNTi6trMmsKSkuKVeK1lRRUDUwylVQza///D833jQwpSitycvOoDIzITTdLr0ouKXQs988tN/TMz4j6l19QkpmfV/xfNw8A "Ruby – Try It Online")
```
->a{(0..9999).to_a.map(&:to_s).map{|x|a+" "+x.rjust(4,"0")}.join("\n")};
```
[Try it online!](https://tio.run/##KypNqvxfXFJkm55aUmzNlWb7X9cusVrDQE/PEgg09Ury4xP1chMLNNSsgMxiTRC7uqaiJlFbSUFJu0KvKKu0uETDREfJQEmzVi8rPzNPQykmD8i25vqvYmdjo5AWDTQ99n9ovm9kSFFakZObR2VgRG66WXpVckmhY7l/brmhZ35GFAA "Ruby – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 11 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Takes input as a single element array. If we can use comma as the delimiter instead of space, the last 3 characters can be removed.
```
ïL²o ùT4)m¸
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=70yybyD5VDQpbbg&input=WyJhYmMiXQ)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), (8?) 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
8 if we may output delimited by multiple spaces (replace `K€Y` with `G`).
```
ØDṗ4ɠ,ⱮK€Y
```
**[Try it online!](https://tio.run/##ARwA4/9qZWxsef//w5hE4bmXNMmgLOKxrkvigqxZ//94 "Jelly – Try It Online")**
### How?
```
ØDṗ4ɠ,ⱮK€Y - Main Link: no arguments
ØD - digit characters = "0123456789"
4 - four
ṗ - Cartesian power -> list of all pins
ɠ - read a line from STDIN
Ɱ - map (across the pins) applying:
, - pair
K€ - join each with a space character
Y - join with newlines
- implicit print
```
] |
[Question]
[
Write two programs A and B.
* Program A (the encoder) takes 1024 pairs of integers \$(k,v)\$, where \$0≤k<2^{32}\$ and \$0≤v<1024\$, and all \$k\$ will be different. It will output a single positive integer (likely a few thousand digits long).
* Program B (the decoder) takes two inputs: the output-integer of program A, and one \$k\$ from the input pairs we've used as input for program A. It will output the \$v\$ corresponding with the given \$k\$.
In other words, Program A compresses 1024 key-value pairs to the smallest size possible, and Program B must use the data provided by A to recover each value given its corresponding key.
Your score is the average value of the output of program A for the test data. Hardcoding for a given test case is forbidden, so this should be essentially the same as the score on the pretest data. Pretest data and test data are drawn from the same (uniform) distribution.
Random pretest data is available [here](https://tio.run/##XY9BT4QwEIXv/IrJmk2oLAroaZeu2WSvcvBkwhJTacEBLKSUk@GviwWyKPYw6bx535tM2jRunqbDcIMyrTouIGw1x/ru42itpArf/2lCm5aLDKWACHwveLQ62WIuBQeUGnKhFZPcHv9I4AuU0J2SgE/LxPXJbeAoyXmubbL3DtBbo/2TobQNYoF5q1AWR8lhkrNawZxNDYdhZIrjjJAS@9Ew@Ut6XfYQkBlcwcUIFyGaYuBlPuEZ2CwuEkpLAnmta3PAb0KjDG4cm20H2@4iNzsod8vNvkf@bGMxJrSc@97qh@E7zSqWt4N7vt5O7Ykjx5dTdH57Pr3eB@QH).
```
Random.txt
MD5: 6FA62A283282F5CFBC6E089B2369C9B9
SHA1: 0BF7FB62A8566575D4A948DD34A559BAAAC422FC
CRC32: 2675DAB3
Testdata.txt
MD5: 6C8F90F126C8F3C55A9FC9F22733CE55
SHA1: F7D11AAB54393DE8CC4E75565950D8C6D9CFE42A
CRC32: B3DB1479
```
Actual test cases:
<https://www.mediafire.com/folder/i6hmn9zzk73ig/174035>
A stupid program A that work but totally didn't optimize is [here](https://tio.run/##PZvZjgXZUUXf8yvy0Q0InXlA4ksQD7bEYAnZLWMk8/VmrZ1lsLC7um5lnhPDjh074v76v3/@zz/@of/1r395//ktz7//8U/v79/f/@H902//8B//9pta2vjln573/Zff/sPv/pVP/P4Pv/7Pn3/zyz/@96//9Xv@l9/4d395/@4d/Z4y1qy1lvH@PZ/8829@@wu/8Bk/P//ul@fXP/EP72/@8stf/9pruXOUWva7235qL/XUscZ9z@5Pm2OP1c8o7zz8uFsf99693jEPP56zSj@7vvfy42ljl9V7eevazz2HP7xlvW3Mh4PxmXLGeWsbT138cV9l7XfN9vTRax9l1vXefZ7Fqcqou7x3Pu2O1VYp9b5rl6dxt9P2bf09tzyj8MrSy@S3fT979t0an3nPmvxyrtU4w3hnPw82qWus0t41eOfsc93BjV8u9fQ@B3bg0e@o9emrj1PrbBO73KeeUy8Pe@e8z2h7jI2l5ts6f8ll1up337eeZ67aytn7vFzv4ep1jHX65trl6VhwtsP1Xgzj1eYe94z99rY4URllaPL3PN1n8NQ@3r04be0VizWvPYZ/yf@tvdtbR334VR1944AXw@A2/nK2zr15PD@WceZs3gWj1N768gMvn@z1ruXd3jrx0pyl7VkPTqvFM1ysXW/D3zymYbzJjd6@NwarOOwMbLJyglYwDK9snO@U2g926S@xiMFw5i6ba9f@fL9Ypb4L4y1CD6N2PM8nW1ljY8nVCSkeM25btzYsS7zVMwkvvMlf9vJUzjrPKb2@eFzbntH5e@51sPzE8kSRLuNia9exFw7Oj@fOu2458z0JeiKjkTXE0OFihPg5nJgcwL04lz/RR3URQiQHHyfAJjGEK88lVrlnrRj61r5wZz/vLDxoldM6lynclN/yVsKY/3mJkWeM44ebv1xenCOVjVfaJBROaXeXur1qfw5OWNiUoGrYYfN0YmEZf@RdPTy2cGyM3R980jlkwQ866bZ25yFUuT9G6WvgjcZzDFxycnO@8@6OASvRiNsmMcWJ6iJX@D0fPgRn3QODE/jru2o7hZDCXoTYIL1vu9yAsL916KkzGlYkD3HjBmMwGQZdxtEmbCsQsfgR65PB/GfiKP6STD@Ly1XfOh9wjNfw9PtuHlTbaiQfEfueyu2KL@r@LX/ykPr3kNWH/Jnjmb3chqFILs7beQd5CML4IICtFTLCQN9kl8afZ4MiJO@zFxFKsK7NK3kn1p@XwBYCx@ZfnHPwmtjEy8nZdrD2eTgMMEW0vGAHfgExMH95CWljY5LCwCDZQ0AKAsQ@f9nNEFLp4tHbCd7x3E5U44u3C7OYR3C8ix/rQzLzEyAfb9dF3E9cvEHO@pCfdZrgXIukJKaXCW3akf6dFDwASitFGKg4nP8nt4jkZukAf0i1gimJPuBl6c/hETh75QXY/RCAeLtwfwAFZz378g78yYkII8PPUOWAd@ttcAPz8VHweeIgbLbaS/Tiv5bEA4LX3BhhkdAAGD6yRoDZZAQZAOZejIn1SNFbpmhz8RCJQ7h5l8FTMdfmrDx0EJgjVUkME7MOvgPXDVQsT2INS6JGAElqwgAQw/TkxuVaNfm6DrmFCQR9isWiHnAg/lJs5MSjHIsfMPOkIvHWnmjrJiFXAWDu1EmgFO7kRODLbYeYtxK2IBNQTDFJSHN6aiqVh/jaArlxQFLVTaZP3QBgFw7lGeIHQIRCQWRcXoOVMWcVB8grCiPRNzkDhgcFisneLLgc93q4IeThd//ytoqjNofgTM0fxhXzSAHMx2/B1W328mcAMv6c4hTwQZY3EofqQMiTfg2TjZ/cAbsLcdUAGPHQ0MQpxIIIPYYBCcK/JDTGbyTPMupBdasNxwE0eko5VZx0xooknifcmAz4B6pAQJCriV7gS6FWky2EsjBL4eREizRck7DnMeA1@ECwEpz4BY@ebWyYEnE/HiKQMakcRXSvJNMV8SiTqcg7XIg3Ul8v@PqCCBQNArTJGSgTBAAQAjhAfnAUnsFlBF6x5lpw9jbzPP46FnOMJpoS3MMaw2c9cgXVCikz1wArOL8XBx4pEJwNHMOtZNDEyIAcQCDIDBAeWgHupmL3jjOJrWlskZYELdBqxeaslFMOdj5UHpLGuXWs1IQ/PBwMQAImH4sYuVswFDRGzONQnGGJ0RSBWXgNnhmkFI/Vc5MffU7B9pRm46WK2HOBF1i8Gy8EKPxlDpwMAJialFBB0UL7bDnPCOeZgn8XOghfcJDXEi6ckaN8iEXVpjJzSNJeLsVrzXtyjmSg6AJhOM8n63jMgDdI3hBDogMatMIzempx1R3QHmkZXoDgQW@5PI/qYxZYdhXXOTNJzN0pvlSaB5aDlS48DGSAvvDvhpgqmSFxzcJBtWrmnFizu2mFWaCwUOrwVj4J@SA2SWW8Oh94k7EO8nCdRxI2ANWVom0IA3XXvywUB06yJZFck1fAKAlhYhPjy5@u7HyEVJAZxAqpSt1LKFGRiXCgh1QGN@kLCEmOIcngw@MK3BB@MpvA4p/upS7@f8ZhvkEUjpRPbQ8yvITIA7wTWtCD0DKYfpfBBxIgNiKf9f8VxkV76DL80p8a9BbrgpNLMsW9K3BWRJppvaJsFDCNWjssCOYmUYtTmhZbIA5gTMiaqsa2v6QbwJ/zNkrQlQU1uYoYS05zIv4UVgYmw8E56SNTGQeaRjALk1yTXxPqGIJ6BYGTyBb@kpwnyDbVbKd1IrtJoGEC8VGBYUn1T2BzkHZkJH4Ffk1boBk@BRLydLEO3OOoK9FAVlA8jiajk@DmsEQCeXhzzMuRwB7PACqJBZd6VD6CJz/BEnrYm3bicco8XjkPLqUB493JTIgELI1S0z/2B@8j/2nYSDbObztmKt@PAMChKCWbukQ@e/5NKbTfODI6nD8I8yZlno8G0vzUMDkbVRUmbjTbCxAoVxpKnRSDoJcEJTcj34mMZXMESgL8j3lVQ/2wE5WGQrQ8nkV9pTyIp9QfIo6T02ta6uh3lt0QsJhWBAa@O04kxjEBkS1wk64pKiAXnzaXSEWq6/DPlmFjySyQkiqxeOFZUCPYspWM1AGqrekrDaDG6PgghUtOwW8LiEIeXfHbHmbYfQGuxH/ChDJWJBFE2pLXf12dkMz7gFZSZxu3JDSx1dITwJRJZrCd5nakXwRNjsWqSAWWVcUGLLkNk8F6zdbNJ3XZANAAKBMmACnET8btAckL4lrssX@o0kTsTMhcIwjH97QT166YXxL0xB9AOZIAdNRYBKpMCEHR6GBsaXY6BtsZfM/xgRBdKe04cnfuuiULUAsYXUsDAZLzLzB2lXSQMLyq37SefJRnU0tguSEdBKJZgFMNmytJH3YBxy6RIC9y2RwKvG1mTDNwqFb0DgNb8NaBSbkPaMmRoYNqC1RXi1ULiwNPKNPySKkNRbrUZVhRbkloUof4JwRIXrvavoO2eMP@F79QEMDSbhMJ/B1BkGJULQti07TaYAfiT54tkCUiKFJUJ6r/SM2GowBulMBqY9@5O4ckYK/VfwXIfA0oxYeJDlBborks4XZaVSXC5FIj4tBExLH9sAxT@0fi2Ysfwjm8wd4Ahkr8SFfgJ11@DxOjSiu5VN8xrTRgDn961YEoieDneULiCG2QzF6gKrqQRpJkW3RimwMttRv5vrFyxQm7t0ujCujzVN8JRpMchC@ZiPtJL8rV/Uog76RYGM1GkmgP7EF803HQhWFramJC1FcCHPRIuJTHkl0WOdsB6DZPI1SOYoguhtcdCw6Hp@fYBqFNOdGMn6gQHbDGQiYUmUZAAG3pyEl/AVO/mCVAHyUuTeLWuBYjGMxJXyhdIxyt33RsNNFcR2z5JI4rD6PwEg1gNCUVa96wyvKxbSBiUhioiNQ/kJ1/Q1ngsZRen0TbWg0cMgv/kglpyiAv4CqXV1yiHGGP5c1BzGNluCpGXRyssQMfhooROWQQHEiKhj@I7f1hP22c3bzsaNA@WeNJNxqsSoABqfAe7GTUcUlSe5l9vgj0glgQkwaLLBFv7Y@jdRlHgd/xEycGbK17ALfyF5znxMQEs502VXeXAUXWohSRYnvWoi9gPoKKiDZaJKRNai2Nb@p8CmEEJYjGFWyTaCOwKLchlDwNULIs6UcVRvgwAuzgsRmAa48Hjxm2NsY1SYvx6JeISYyrYOnjACEskrOOHNZKKtWj56Gzxe/pQKGeAnOxItgKDImhnUMIR9cvdua8Zxu9eAlAomRHSIEVwNqiA9GwVsoB5U2BKRVBbJA4AnXLIy5Frh45rAmfEmhiZYmY0jKF0aVJTje2ud1rIvJPIJdS3jD5L1fluthETbWR0JQ1IDc4cpbReqFAJTFGWbHJ6VZJ0nT3T5ADIeEzqsl6pW4Rh/A1LOQeBN2WtUpMIZs6u9qkWWV8kHoD/rXdU@SAuIMxP3VDI@DX9GyS2HPUbmeYEwYWTFfw0epPZKrP2BPw1n5VI@g50neJ51RG6FOYFXamIwCx@k96Kc2WvKckbY8NNSdWzgbMbU7VsHgrdIdqK6ArX1uqaKeGDMCGH5eMT7/pUY/5u4X3hw09B@buS5ZI/a8kBziy70097XZd9N58WDGeok3WYnuytB2sL7eQkk/rxg6TrVJe0UD2pIa4UoGwj07k8LR1Kojqwar6PLZLYfvCFmnwtRGv4fRtpOBThClC0KljasHgJVj@qMkIsBT4HuN3mc/AgHBkAQn0gSOHQgFVwr9lTl2y8HC86hACXOCeV9FhpBVV9AVVlcmj3RZJOACLTbpVY0cZuulLVLZpdWtLKbAW6cT5Uc9jdwOd52I3lgflwILz@cVWn2TkE2TP@GQEyTPA0MuHOKSE0ct7aPH3WCH36yrSwAGaSv0uaXF5KoHIkeB/FiS5s5MOHsVzN4W0SnL4oF6QuFz7W2oKRUdVOjSaTINmqympRpGjRPPMCYrHjQ/pYtJfUIr8dFFxHdbzSdJdFbIWROTjDcTkSD1THV41jZXrLIHL5BSivf23jaJpALbRE5D75DRmwqU0GriD0J6WT4oRh4RM5kcIFd63/GvRpIzlqUd6m8EyGkpbq2b5ombAq8KM@zfQKLZWJVIRECgkOaWySeMU3JYOizYH0xzJzI3i4IPh5VAv2NVR5uS1gBegDoLmUIuySSDSY2KJFSHDtqb7YcKHO8zMENK0bRrbrrSuSpDayzmdaO2olUMW6u3bQ7w6X6JeZax2HWscm9ehWg4jsmhqcdsnM9GGVilWQRyywCc4heKEg5xGU6J2pExGcT6Wt/MT09XRy9Cstm1DmOdVOF5VyhkC4b2U2Eh0YRysNHlFDLktR4ROSPw7F4QNFRnt/QmwlM0rXQccr1pDC25V8ob37Klz1cbUVqSwJzwUkOXNtDwn8CKud2UHKXdXJed@ewdYHaHwqSa@jAf6AaY2e/5jX9xsRCL@R7SB/JPqlh4FCkifsw3Ig9O85oyBD3zR5pBJ8rE/HoWFSIH@CUuO8@jXcK58zfEZ8Fz4rLOYqYI8nV5RRD@ZFZM6YGlNMdzUAxcI@a3eTCsId4A5Xwd@ikU2Lcvs8chkPnFqtzetTg5blwQV30n2IOFmJXzTfnM7TxMq4g@VfYvm/UaxgxI3bDOoR7YqzlTw3dkhoEM@Tnnl@pcOI5ySZqV@guK2Bi/HUE3ewiuKwzHsFqUfw51El0gBz@Ap9HtyJXBbocIKecNyl4o5sAwLko3AccgH@2yO31PRwdBXxXsfEZ1sEB@B6wuXUthX5lNWOPLwYIqKu2aAkzvoXErPZOLNILGJeJD5YufqyI8z8AqCRS5POYfOcRwM1B1tQcGVv7dil7PTe8WIazvhJIgkpfTb2YEWUI7Zo0LhcBkjXUVoVlMgqg5BScUK7aNn2FFY1HWgizDEvb7JSFdshkAK2nAQm6P1xU86NOihyTh/Rte0AXvbivJE@zPn45GaViSWbXNy1MKEWufl06eB0maRAldKzjevcTxRU6VDp4ZoU8oMefFCTUHkG1Bv@3aqpdDkEHrKpMkmik4RiD/ZbX6JvkiVsh2JhMqAEAqFsnAFJRitkw3Hs9ygk7iydqJOv/JZMnbYiFkk6SGhAEoSIyN0xd/6qaFqL8RtgfpwARUkbKMrVcAsJYqaMACiuwmBGGQ5Ag@No/biaz4BaE/h0k7boWYmp5KFFglU9bFmnp6BD/CrnqcexOU8Ep8H1YpGrMkMGQsu8LIeX3EjElPEmZ05krhFNj3blIMD2ZmppVLEHcGu@NLefk9onWJ0pNWjZvczaFXvysCM0pcfh0LTiK7THtLR@pbGbDnsU40BVx30Xlti1wNkPsuK2pwNWUQAQOAOpk88CA@2qs743pM/3E35nCQX7txeECGcPdookJnnm2xFfeRiaknjE@GrhGBK3SEPMkkHWcp3PElp/JNhsb1681qZIKir2nvUzLxppbpsW5WSZ@PDmy6dAN42hoqRc1nHakYgPncQn1x75KPUAOn1/oYpEqbhQAIUXUrIwu0yi8xH3Nt9caOECx@qD1aKzFLwNvEgWWwSVFUEgKk76NdppddMdL9dDbjANZENXzWz7rAQNwLHVrG1KKx49wt9PDcl/CX6s8NyawYxOHgrJgsJzPxWosABiT96pOaYvSZNwJ4RdOahS6AqTyZyzcnPEFJ5XpYfSNHHac1WWTgRhfGfwALmfiVL2FQNJJ@4rUO7aZ44nZL1QGxcTYDI3G/edByWU66tLMAxTMy5uUIrhk8L3GqGyFTfXIe7YCNKKqFCoLfPRs43BCEnTOlWgSg5jw2UJIwnqxWS8OrhtsTXPpbyRIWYbgscJ8aORqqaIxXM/HaYs3TavVkBIKPd6RHJuUraSshE8U9tbImIqJUwGiLTAXnkBQxGCvja9OUOAe@nKUaLAMoW1MgP2z0PZZiedYfAyBJwrYs1q07Qo5nmYUudKGfDVrt@1GnTvHAbh7g1hXHaSCYXvQ91ihyTuWtuGy/HKTVs4ngb@7hI0JjrghscOh0V3srO1HTeuzQFjBQQu9mpMtslTIa@ZOPYNUXqmqZtzU6JiTAj4mx3OfSAsgMnvLRZtHVKXe4hLAq2w2KHZ1F8XekJ6e9Wi3UT6zJQIJ2ysp3/ZbMCKg6g7Jopl42Ts4qxv2JKBvBpOQXVdGeomgbSLSL1IcUal0foU40nD3JEFHmZFga6nQgJ7URcUx8h@MJyuIHUoH/iGAZy90UgqM4@qC10HyuSnIoXSH8ctf@A3PZGI3YviuDch36qOtWzG@GIioqdOi7G4D8bkkHuHwBbf28VHIfcZMeg1q0ZQY8mp/q0m00JWajDfbdQhvtpJ@MQQzADB/LD1pHfPmP7euqctFit0x0gJRDeASkels@b2Wy1D7xlSgUiGV8XsSDyX3en8Led9fBjeah23RG9syQKE9XwqkHgd@Wb6gaNEnJUNmmC6zQ3s1qyVNlFXAAyH/7OYdJc6bSt9cX5lgxaUrkkvUVQnhntQ/D3slRJijevPJ7IxtZJE0lJccXWrlQ51VFp/VYyrjLrdQi/d/RwhUoTDyLm9NNSNaI2ypFVsb6qN6SAsAaltGHKQrSOQ0NZu1I/d5erOO4Cot33oWDMsISu2mCx5/iu0Th5WR@OyJ@WM5AaN@FEqkCTphMbHIFYdaTTpfT7cYcCsqo40b55oXMr4zd@I0H5ncNPfoSeqefJ0pyAeGsQZrrVkvUhR8cqvtlfgkKDV9sB1HAWbmnt3eLqCgwdl5XKVYqldACdtX1WL3fMpYCo@iKNtxjY7BgChrqHAsEVtukajFABxXUyh1nVWsF/1awZAmEegV4y9ROOvuQNLRthqkSubvGrbhNu0@c81p0APkP3e6VzNvfOrEn3nmUJtyOENXq1En7XHWk6@tNMTjVgkGBMudmFo4gFuGV0EeKcRJwsktrAmETU/6OA2zKYNMLTyHVXu8xdp2KjZ2WANKkwtNd9PNsSu2eASX7idBkOujPLIu2n61x6GcY2yY9UJFpDyZZ7adb3iNqUy2jTbozJ2ylxVOpSwtspKLBg8lcSrJZiiq2epTR3VSlFmfSrnTuGIfBLyfqgY5f0Nz3DUtLcBsDnTndruloMfYxC4sraVXNc8e6WuuFep0LidhlCHWBkf9UVAqfPlFjKaLQjGx8gtkWFr3mDwBti47IUWA1bS7MDNSiSGyM4pczevdntEA@LPKYYCyb10@jBKPecTDhhCMTCR9mUACrchdUQ26W2rpqmsqIoCnNxyShsMCXfmt36WH/7mYChMNgd7MS@ih/JDvV1MkP1s8VV246W7MqbqZxmTmVOx5afdauTXeO2MrhReLYzhfLBOCX19EHyi0jf1dWm8TUP2ctwowM0oLC5PkFKd0NKvUSJZ11ZQDbCMvyUeVokZwqbik1pP6NGNzKzk7CyCNGy4ijVhnO7nlqcfhDD5iu@pBe2k57ZFDhK7ENq7ApY5ZdVI@8W0bKquziWgi5cR/GuyOa85PJwEryzD1nDHQ@G@rDIlYhZmjM@1/boR1eQFjPZelBh3JNy/KJStORG9sPWVZCu8yQQMBPh6U5Sd3fh2Z9WTJp3BwvT2QHAPz7IcCxDvJSMNohuZUanrSqsCkzFdVVCYtgfuIykWvS2FipM90MFBC@yR3Yk1e54qULapXE3cJ@adtzkLApixybOASSJ7sTCNDnLgWp3OL88vCtxjp4hVHJqFddrZrgESWExCLn1CLuY8gfRmgyI4DFV6kpWa7LHNBXh89uaCrKyx5yZqX09TGaF4bqfWxw2p7irynUnmD@6fhVoLIFvk@dzm@NqvVtFLhxh6e4ssUp/91JT/Krsus49FOOrSKM04vonSUGcuAqlOEbY20oob9ihlBQTLLRA@Ch2jrP4CKXTTWVnzj7IvRC1yrSd8k7HyMqc28GXZIkmoEvHh4Mlpxsu9EifYe/920dtJeMsh4x0CK474T1r1Ez5gF9EZLH2AULAkFqeOVoVFWAq3wrCViUncalKxyWJqVzDE98aqChuo4ciC7dGFORnBZqz@x7l9ETWw9PD4fS33lfckZexAZmRamyo3GPifDAzfJh11FYzXCPK4arfMBW2Bc24y20YWyZg1/Jwvwe3zOWnGwi2DtkF5dBZSZ14jcwno9anPNJ@iE4ulEWSrfUbFbq0FkECRpDpnz2@@@TAoiM1dy2HVR@MbEa2X/BwSnk@QUiryHZ7dEiaYoEPl9pQV1e7HDvfbIWrFslDjiNzO0tXaIbs14VaeYUbFOZTGA0FdzrUdzHH7Q@O212XzncsrttcACGZeR@/OYLf3EV3Z9bJL1m85KkyyJLVTO/6rd2773Ndw85O5LRwQjP5rWeCoN7sFN4n436/QeK3KrIIUx0jZAItNdruDpjx3Uqe4TThNB1nSoy2Ew@wdaXB3sueNouMNcsspUVatyfojm3JFTiA2xbbedvNrr8p5O7CcmBxSnaHV0QpkS@cfMuc7NVVR1eTMZrhzbGZs073fPOk5aalK//ZoIXXuezsaNGBmxsHQzDJ4MlvpaytCpvhnGvDmyLpbmL5ruoWfugbdEdKu0nLzOqqbHeL3e8tETD8foTSg3ncNRkIoPKL48AUflp/U55UOxduJbRIeUrOUD21cp/Hzk7hTnXUWYX7X05m0je6dnzc6rmZ@rou5zJMiYLsRKopPe6kp0MDZ2kq59GpHRe616hc1DO@ouKpAWV@6JwqvHrmuxRdzXi5g9jDlJbFxicFW4D8nQ2s7WqReygqd/jGLTSKA148LWWI@9ImWO4@bHZjfflxTCpGgB7uX8@fbx/RrPglhEjgxZV11X/qQ9a6LentZ80QQnldUnL3co4IaX71Yvwwbb@YxMPmyqIHrUvpqVuEsBgxIGxqTACV7B6urZpevgmtt89mT1SA6yx3hAHvlr3emoXx7H0719hWk0zKBO8iSRS63axV3DM@XPGzPGU3wr1cxxhQsJ7BUQZ7xQmogz14IDXUGZWpmq1uBXvNu/N9srXy9Zq32aoqJjmRKwFZy6BbgArtT/YUXavgHRG/bJ22G8mpZyeSGwDmL5UASyQJYluF5Rxj0C1o09oppJNoyJX7FtPtLIASsHYJxZZ2fH3sfKarcbCSkiVTuvzpboQiH6GtHu9sPzVASnmytR8XkaTOgWyqhG2XyG02qUn55hQ9BQjmV@G8ivB1zZFo3TbWltj7bTVvh45DbpshujIfEdy/vX0rFH9LUO2sIRTHY6pqXdZ8fbC7YxYepVHoQdmupYQ2T7dFHfQmlqv7AzvfzXC/QS3MVJbe4OKIDW52US/uQ@7vls5U@CJs@pbpZxnPBtx2jrf6NSG/9TfdjiGUacnJRAUvuIsQr6JN1s6QL2GMNKy@Mdsi2VgCa/3K2FJNIAl7FCS95ygcZq3YBuCpPPf0ku41@Pbx0zSNbE26/@@0FCjlb/LVGod3KkjKFFnfDnetft3xm0vtfKnvhAKXr6xwdn9U0nAQRrWygfkpK371ovZMvkeKl310FoWxALWajKcqLnPQMfn8QvfWyNl@B8KhJl3IGbYcmdtfq3BzD8vlNdHeoYh42fKlHILXmWb6OMBSBqfGv62n@a5PS19scQXDuSm@/WgEyaFIke@wbRH8ulBsPnBroelkMqZZ1aH9RsTO9zYFATlwar/fheK/TphMs8dXy/umfO75YcolmebB/wc). Its program B is easily written.
[Answer]
# Python 3, pretest ≈ 3.198 · 103085
```
from hashlib import sha512
import sys
def encode(pairs): # program A
elim = [[] for i in range(10)]
done = set()
code = 0
i = 0
while len(done) < 10 * len(pairs):
e = 1 << i
for a, e1 in elim[i % 10]:
if decode(e, a) & 1 << i % 10:
e ^= e1
for a, b in pairs:
if (a, i % 10) not in done and decode(e, a) & 1 << i % 10:
elim[i % 10].append((a, e))
done.add((a, i % 10))
if (decode(code, a) ^ b) & 1 << i % 10:
code ^= e
print("progress:", len(done), "of", 10 * len(pairs))
break
i += 1
return code
def decode(code, a): # program B
k = -(-code.bit_length() // 8)
a_bytes = a.to_bytes(4, "little")
s = b"".join(
sha512(a_bytes + i.to_bytes(4, "little")).digest() for i in range(-(-k // 64))
)
b = 0
for i, (x, y) in enumerate(zip(code.to_bytes(k, "little"), s)):
b ^= (x & y) << i * 8 % 10
return b & 1023 ^ b >> 10
def read_pairs():
return [tuple(map(int, line.split())) for line in sys.stdin]
def test(pairs):
code = encode(pairs)
for a, b in pairs:
assert decode(code, a) == b
print(code)
test(read_pairs())
```
### Pretest output
The encoder (program A) takes about 6 minutes to run in PyPy. Its output for the pretest is:
```
31983609135966228809777741024866634396367955850954563312910243722966419655757435319862170247982609333805811315728884450895580799383047152743378820273077053884539894357668608677003723034054150072472679319590110643492810118920515801395958239291576592748237372467748241886558720871264342908155191777359585845696600370935487361341785211913110481040589139281898484188938846817560295768498881287225642023856190028544427590648046456036574330957328066402924125404073006144179946215625958643494081212962075340324684130280414625483652805036566339457267551141894682726365505972133784971174734160698976154775811488656096461968463830423074194023690503590590775033695214423998615444187716064686144001451215863398975347419967640878071667106313050954800893007781291647431510389526738768573353015452189679155051541561231146940706328809607485776138460159591319080343284358448724370020894125934538601889550086934233091980254236012141359542061770911092807766526451019824031548581065916355093797436687555279312288875998494044065641530299531661256941700326425163573657004343895103496724901715610405315696830871086538183435694121760474073023458471744226820280782007502797691083190318324487197753443963571848733746071847847503077912802000091614327968964141450181973360651625471354587026290724846906554164924720066533282988840115094797514460217879380690461261835733295861803705394151420199059533051945944829244868440580371672125590557347324783817602474773801825029895884776404639198926793779867410515553784121435319134307253638568331529787781235084628432871984360992875472633958491882569077293145250495277979952525973740358428525766027507530317692602517027217679810063987302625422496799748842451355136627998296037177558122844929449377522984595368107136303866235523533278732324181522202203636626264487517560120680389621562028772569157498411869721766672498939022664474767985892820170334179252554511620260319259569593256276255895000364202791049913505972232782566530566341223654980901733905002516092163056581626593518077383131036496001950185439305868415290006860241666136700655660075381115903744293277973930796274779653647714016073922883203769217980038066409200998466193202329090278491648479911508276027286548829602558975386937067679077276971208214625876007703346632539055994199462748282900998214486645162277623073498410220953186861172886747394992230973314265902007187446129816157393697305312624793190210450979525381906198852578619071224265649145441460469662250448218764499047348362548750003370944772956154662554023857705149861774126960045122299555516709305181620013892453158471100545618056605123335183465355868672237737792628988379889459029444873409805140995088383991356246685699313569301017907549835057806089472106637383136584875471496123974387658318450782138871582131161643221907721116143710024435066884630344739171885220542678102635637192667329306874983507141585026570891055701250722003923329858567937864129882737742073320064153568198296932909448928951903564049064190959836027425436414766746048788435990514173396582362591284614310722316033029018983309186148295917238363165751109139219360789557442877663768774219
```
which you can use to verify the much faster decoder (program B) if you don’t want to wait for the encoder.
### How it works
The decoder expands \$a\$ into a deterministic pseudorandom stream using SHA-512, bitwise ANDs the stream with the code (output of program A), and bitwise XORs all the base 1024 digits of the result.
It has the important property that the decoder is a linear function of the code: `decode(code1 ^ code2, a) == decode(code1, a) ^ decode(code2, a)`. Therefore, the encoder can compute the needed code using Gaussian elimination.
### Scoring note
For official scoring, please make the thoroughly negligible “output formatting” adjustment of adding 1 to the code value, since otherwise a theoretically possible output is 0, which is not a positive integer. As of this writing, the other answer has the same property.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), \$n \approx 2.088\times 10^{5033}\$ for pretest
```
a=Block[{aValues,bValues,p,poly,i},
{aValues,bValues}=Thread@#;
p=NextPrime[nPair-1];i=0;
While[!DuplicateFreeQ[aValues~Mod~p],
p=NextPrime@p;++i;
];
coef=CoefficientList[PolynomialMod[
InterpolatingPolynomial[Thread@{aValues,bValues},x,
Modulus->p],p],x];
coefval=FromDigits[Reverse@coef,p];
FromDigits[
Join[{coefval},8191~Table~Floor[i/8191],{i~Mod~8191}]
,8192]+1
]&;
b=Block[{i,p,coef,n,aValue},
n=#-1;i=0;
While[
{n,p}=QuotientRemainder[n,8192];
i+=p;
p==8191];
p=NextPrime[nPair-1,i+1];
coefReversed=IntegerDigits[n,p];
aValueQuery=#2;
Fold[
Mod[#*aValueQuery+#2,p]&,
Table[0,Length@aValueQuery],
coefReversed
]
]&;
```
[Try it online!](https://tio.run/##dVPva9swEP2uv8JroLSxwmKXjRWj4WYlsNJlSVa2D8IDOVYSMVsyslxSgvOvZ/qVLO0IBEf2vXv37t2pImpNK6LYguwrsrlD8e@beBABfR7pczTUZz4lTNqX4Kof8LbKqQzEMrgiML8Oah1sgv41AN95etc0VCrwg9JiTnghqvRjdPPhFvxas5JiEATkJylb2iAX/coVXVGJTWVoy2SJBr27b@tSK1J0LCmdYZ@UgQwURBH0tJaUFOnWf4f/kY08WZfsCRqVYvEHH8G5/69hLcoXyDqoK76NdocaPaOnRhO6UVPJKoot8SDKEoaGJuY6O6N4900UuzozFV6xpHUShsyk234Xgi7RF/1YsgWjXD2yRuGpVsdFxUipSbBlMB1KrVqPi6/@xfFbPw5NwI2rHASaoi3bZvBZi9G/zbHsMynRWIrqnq2YavCcPlPZ0NSENNCgTqKW7EEwjrc@t4Ofotto90Tyku7GpRASs/fmUwa3zHZvXrrMZhpsnIURyC4TkB/mwvQkbDkOnX47EI56g@i1x5Zjy2HdoVkrlDFqrleX8UIPnTvyxIJYiOrEe46smjNThCyMjlb43gvkF8k3zb0PTtyspfIF9WLrjCj9YMyEev0TRNiLddqls9@6g4fwkfKVWqcnML8Zp9XNThiD9u6eIZKalQdaNlf4YuIu3w4FF3CSOkgGzm6vTXV3EufYweHhNiGEPD7b/wU "Wolfram Language (Mathematica) – Try It Online") (generate random test case based on random seed)
[Try it online!](https://tio.run/##dZxbj13HcYXf@SsYCzBscQvp@wXEBLRjCHDgKJJhJA8DBhhKI2kQcoYYDg0ZBPXXlW9V1R7JCZyLLR6es3d3ddWqVauq9ebq4fvrN1cPN19f/fTm6offXZT/ruWz/IR//j3/nBP/fPvl1c29/eHpbz59evv@zavr@6d33z79zdXx6rdP3/KX755@@tsnT/7j9sXv3r27vn948s3Vw9XFhw81p91bymkes8yPx4dcU165jbaPNSsflN5mG3W1dPRlH8xS2957jqP1ZR@sNVJdMx972wertJlGrenIQw/da/GAncZRWufPdS@@mVZbRy5Nbx08pI405jF60TdazbWlnsexp545WGlqeaZj6wllt1FGSnkfYyZ9kHNeZe5Sj7X1QUssIdXU@UbVImavsxS@d6zR7Qt9jMKq2tGrXpF5/mgjlWM0W0OvfeyGRQ42rA9qb9iK1xwtZ30wals599Kxnr6R18qbxx6964@tzNYmFu1HqfYENjpG3XMfWa/sI5e05lwHm9cuWs@tjVUnhtEHFWv3stj8gfl84322vdo8ahm2ytRS0yEdemLV03hDbccctotcM7YtMkxr/gT@Z8xZjty0C/46tzo5tAPz2ZHzhF4qlpm28cI7Vu9F@zTT5Vrq0JcO@37Newzt/Mjdzrf3VGbPiwPPyVe1OZ@8y2EOwJ4wdGe3R53TTJs57NWw3Ig1lYT5WEKxVa@U68J69ehm@lZwhpkmhsnV3qC/HCkfwww9cGkOoeI/9v2SRpvYfVSc1B7Ydhk7F07CvDivjsviDTyhas2ZPfS1Us0HXuNnsVrlOex62Wl1Tguv1HHbtsfMbQ5cJD5Yu@@x0@rHiuDCx8ro8tpl2yaQ1mInRJs5CO7BT3W6eZhLEor8CKft5pO4wtpEAnbI2Y5m5zpwh7qOnuyRI61S2WjCEvYNVkGg8F8H3ibTtaWfFH1huGlYZpqcZunmUiuVPVOeMoWMuzi6wQngpsVsNXkXPjXk1xbxefGKxHY4Hv2Cs6wsPXF6fry7lN0XgZDtg9LraJxh4YkeGCDCZNXrmNWMnfFzjrzjpbbKPIhNvsNPljl@no0jIsDGaYqyEk6KZXHbZjCzy2ZvhNfOzc94tYLFwQBzggn6YVzMP9wvJ2GRAa3BB3ZioAj/2zliewKYswZbz1qFfpE5jN550z6mPTKXUQh74uFY2fae9NqqZ0wDUGBoL7BlEbFdP@k17YJBCWnbR@WNYADY548Egksi@hRO02JaB9bXBNuAD@1j4P2Ewpi2BNbAifVN8Dhkt8lHay1O3NGT5YAaZXE@@j0LBErxvAM8s/MExTiydBA07mUdGAG2iVdzdUESMcYTqscj4bvxiF0JDi1iVyKHEzyqJwnMKEDfgw/0AyCFPzdcyD0mD@Kr4yQTxNcXwIfcBTRs2iCBuBmCFQ94wKgS/gugKyk5KGWchv8noi1WwFzcsiVCPJnh8WqAb8gfmi@KXWVex1ktc2w8JmEjgG5Z5pqbN@IPrNLcUm6tQGDZe7rHgGWYmh9YlukcLdYd5SiWZWoqFvIkkdGnGWoAKwAtp@u5j@xD9BFrljM2psfSQMRO3ZFwc7aEKk7s@2y8AcNO2wMvaDh9s@zrWCtkXZw8WcrDgNMinLFLKm4oEC6bOxnYcmBE4mbTORBjLCIaM3kaIw0OshyL5AmO5@ylpaWU38z4lnlZRQ0frgIAtgn07e7HC5LiDqzSkG@XRWyJAZTATtIJqdLCxvYFqyC74rPTk5L8iVDOE8zpfngknsRCtao4PaCNBIiPbXsp54Lxs1DJohlKgFd3VmWHBSYlwU4R7bBtbC25CaCrURmesEvmiCfLsnUW/bFtIbQFG6bmG@SE6QjCz0kq@EN3LAXUwJtCqHY7bpyF3Ipx22O0koUSnlqAPkdwuT2HiU95nmlNrk6@OoAVO7BCuA5FVze/ZYEsESCrQW7gNYAKFifkfd0T45LQgFNDbPC1CGNBvmTMhegkWJQkjDawygEEjE542QPJOyAWoYDj23niEWvKyzz8zIk4W0KFA3BOp1yVCeDt@AxFMG4yg0myAjjGJjccMzvrw/mLOBXpz9wIYAOsII4csZ0ox407JzEPT6lzKua1sbGc3mBe5QECqHkO5RfaSgZ/k4VoHw30YmduGiCdxMd6wVtzC2K2cygAMqDk8NfIV1Av8kbwl1pxBby1u7cCCoQEacH5C3uATrDYdWYWGCMUZ8oxnMjxgMViAUyg3aCGuMUNMKhRPyE0C2VVwzMNia0nXsqJNgtjXqFT73zgT0ycFyRFvpc98/QBgnFG1X0P54fz9YabGBgJGCAQgnFRDb1VbLEZW@yezqrgjPAAt20ZuB4rZ3EnqsJh4CgsHQByRsoyhEDEuoUd1AOg5eD1FnceTMUZAh9BvfEzKOQwNlaDk2QdIoTRaS5nB3WmtMA89tDaelrQNeUo2wtAgnWgINMQBnaINTesdtmfIVULXkA2cAIIdCj@G3m5eKwLBWdVKJvxKB4ocKxesO9D0/B64ASvkCXgnoooUHEZPxSlbaSDERRGIQIsbz0hWcpjdVNkHTPYC@HuhAhez4E5B92qmpoRL4tC/A6oINeHa8JNiCJgETgxtKd@w9lZmKiY/aRtJSBKsmM40@Kf94YP/CLSMXXDu1uQB50XOHU0C32SFc4KdQqaSy1WVV0ZQBkdFE6LFx2ekJS9KFvg8v7nQnHBaYDtwykplsnAbhIGds/MJMQE9sI3mic5IQMxwWEWt@0ADUknKwVUKH70hWGuDA3ZhTS7xSCLczvlB5CFVdojYLlkFeqiZqsWs2sL4ku4OLRjBr5CQGEsy8zQYpUQiScY@uC4k9w9oxQGZQjZppC1HwiohoqxFWDfCHjwAL8gfThwkF5gpSA3b3JcBqXZwgivIgJJi0vGbYbtBD9WhtHLNnYcLBNc1KoMNYVMm6ybTuosNoe15CNuiYqndzG0w9kiLkFpzVoCF6Ba8F5SaT25NawaLKIgJ8htZyq1BSf7JEYwUdLkJPvm7nUoFQIZmgJtOVPGhRrBVFS6dONvqlugT8CsYw0APYfixSs2nG6L9sMQHCGh8rg7@zbkwceGCl2QfZsPKJqzEetukEAiXpASFu00Z1jSUyboFp9ETZHKoORuVetQXQuQRwlJVTQrLkAkmZmIHyUgACNSJvjKbxS/3Vhx3k0/H3JCpwsJCpdFvg5jrFBLqhblbQtWUo5YzohiXyarnJwlaeddfCOBdMTu9kykGrSprt7mgSRYuRxJOznNwn@H6q6zdlda4f2kBYJ1elwAK/hridqNigVIIVM1SshQCEC5pbScnCQN5UyV1oExsD8sXVSc@zOreBJQRWIxlyMFQKtVA/myiUJiR8jo1V4WFedkcMDtHon7VCv/tuskfIHgwq@B9xahNmBvcINisYVj8paponRGdaeCFA9iYwZscgXRs6W6ymwxRaWgXzDlEuUeWYmPOJ7s5IwA5cV1h@zAD3gPeZIaI8gZLq54wyncCbeKp6ZabbkqQCglVRGxUPJFUYQWuaHlZSq9hr1YRbMDYK9gPFuBbrsyBb9QWi7BjcE5KIv4uhNCCEvKQ47abBFNGE6k4UjAh6sbdVqu4AxdDeE8SXNkgerCAXC9BNqk3OzJTujZlU/NVvi16h4BbngW6ZgsDCtqwWBgdMAwiT@7CFSxDksnHLazomGAq5eCo/YT/IzsI1I/nNKofs5SszykCTz8Chc9lheNoiNwohYRI9MsAsZ4lddwVAV4o@idsbmq@gteC2NxWS/rjV2Z9LBVkeClP0IFwH3T2ESNCR8Q1yu2LGGPwFWp4jIO8cMih5RCr8jkd1vI5fX5buQfgP@ovgYyDYFIeBgK4EQENYl5n4mfNZAEFS/umcpegDSFR1SJ1NecDlwg3F9LAMyod3EJewUxrbSuos3KH56M2y1JbO4kMOallMq2rE6ccm7JNsSLnTCZr5J0sKQHMRGOYwHCodkARYJ5nafHJFBNUjdRYPphKOXC@laoAKLAOLr4jFXkBfiinAXzTslsi9VCP/AqyzSQCmy/jb@ns/oBsjrpzpgAWZ88xWckO3sFFETP3Ozb3ZB4xkOIuSi4IXzkBMwjgdOSLlYbsg04vzzfbemVVbidw1b8BGKLH1rMwiBFejlF4mee2YxCXbqPs8tGOSzeQ5hb0ZxxWpIBjBF7ui9jBABmKO79tWAs5Atvd8cTE@ec58l6q5hZgjnzZ9sJqUK5ngTkwixscdmREC6uwsA9ZmoUKm5/EmRS6V1CncLUuCkxI8/zEqCo0FGJVVyhlkiLu4O8bfrWqWKwj2pJc02tEIAbIjnLtT5BmvzIlR6sS7pQJW/cr6k4VewYbGBoql@8ncNwGV6PBiKxW@yh2SbEJJxGU7lugnuf6gNUX8klKct5wdZEvVXlBTGrOk9pN7x1enRwvgAmBCZkOhgTTNj0R5MsMimOdC6RM7KcsEr0HFgevvAh6bWGVFsE@ypl8LvhOC@aK/F/uOFWVfyw98NBgH8GXyVANweijSkwB5bz/kEBVkjjJIxAtzUUCxv6mMJvSZoqVKvzA2BiVpePDdVhgeqt6DTzdDQkPORgztJw5qlqQcWAUXs5TFYJrizqj5RehYeorHfRjKIK9HvMiDIUnmE1uZcPa6lr0YN9ciRKA8Mw3VkRXi8lULWbraJuKVrUiVFPKzfBCKCgwVA5GSo3ULU@BrUaEsnemgI4loQWduLtHhKTxAmpqrYKiCKMQ8nJmztKyhTITczI5SGOsrlaWKOTwu8HPtRc@mEjWGeIiRsvyoQi6Db3Dj5RVU137JaijQWFATc4L1DCZO8mzUwqNQG7nXCohsgqORybxEClhI/IsthRLsC2pqUK3FRdEXXG7BVVxUMd2CvEINmSl7Kv0oIGQUZItJDS5QFNdSWiqg/cuDitkZ4aB1bFGRvGbsYhAUywkUolaChwqoSmxO5Ke@JVeIUafIZT2GFLtGohRKjtQUZQSym6FkmFEckBy1XPh9M0yR0VpXo/A6Aokd6UceUC/aT6SxUqxRbb3nFaIDLItM7zlDAEEPAt4rWdApTKGICqphMNCT9Fh721ssg2rPgy8QicgR0V9blmCrGDN@DgLNPYtdKuqhjvKfJY3jEhEtnJIV/X2YnqbVc6yJikVXVroqQhwil7pGq6LgpGEC/d1pR8G@YBVKFREZJw9ZukDkNzhtMJ9y39tgSG86MCzrPMGv1VXtzld9v7c2zU1uXZS/qMhAEFnKEwtRs4BLKsw/kIxSGHSPh0Jw@kXJYOaY8PIKb4kGiR7B8hqjRcTSTugbl7Z5XLxVM12RB@atVJPduGSeVyCpkSyBZkqpfsJTjrwhpUzZSqZsAlArhNsfKXUC1BY2GpyyV8lgHEkqBA/ljogDLg4MdwGW2YKKbCtPpPcEZ2160rF0X53NhGzSjXloyBsHp1n2co8E2sX/bRM4gG9X7JzNEU32oeLgkYzTtL8EkRBp2Rl8NCAckaaj544wgqxbdYl0tcaqgWikkply7iQlOW0vl6jJqstmfTIXhZ3pS0eDHO4/qounKE0JAQbICjhAS@Cz4cw1RXsHAIl5dmle3DJJNqif3oskYZtpdRwPmWUlUCWzNxyltnl3O4bivtTqXDCt5PgmAllK0rYE85qkq28hKoqp/E7ueMlKC2Jd8twj19AaJGNihSiJbrJEXlozXRQiCkQANylFxd5oJQq4MIufLefFHnji@dHqwGsEjaPLkoliTUqkub3pynGsc5xIC98U2KSfxCndDuvZSuLjMU4mwpcABqbJailpGHPChFYE31X6zoh1tRwWy18F2oVME5FK2@FTCIGFBN3z0Ha@RiqCTg3J1GUxYJEeD2rjNM9cIFXXGK6o2JLuxzKKOR0pvKQnKuF5nqZHLuawbdb6qRoBcYaFtFaNydMjOfsvgUExlqExfnebwwqaGNhaNbhomX@asjF2yM51HVO9ck/0juEjPYUWEM9ZZILN3CRk7T1OmVAmMbq8ZwQP7De0JzKTcRd47oJJ0NH1VrzOVpSVJLlVEgnbpUMhV1kg83DDVjwIAdYwJF6EyhlaRdeBOfVfFCHM/rLOgNJJklmiGr2tAURWoRTZdgNTuxtzBre/GnziwQASHy6h38gpj1GmooTiNWTg0YdLVImswafgAEslFqqrtpCp7riFByOPgcZx@yqvkCTVfqSclHTSTSyRuj@oaACwj647gLpdqckiFa8tZJ0oSNyZ0jJLyponJJpfU0oZmbrueSaTxuJbpaSj07pmr9ZeMrQUmbcDClHmRPmy0S2c6BliltB54g6PSBla6ahvglqSZPJC4P9xNwBoGZptqPQf5ALAndqotc0KSWUPdQoxq2twp0qJrCl90v@AWI0VRgOzkolAM4JPSvxSCOmh/Z1X5X94iLBGVka65fYkE5gpRZT5IS6@FFRFBxwMZsQ@MzQY3hH3gL3yL1dId4aTAaYoi5CRGpYgK/K@nZ5nKs9brMGHPqK9LmfZn8DvRNMniOKBS/49iaa@tsTEKZiZwhAU7r7gpbt7GBqVCHParm9p4BlEajGCM8QSrQ7JBlNWiiibCkMT8OW0iFtTY3yT4@aJI6m6mIeihQoGweJfdQ816KHxnBxz@2BBKNIDljHOITRb1aT4/ANdBMJYZfOVxJqlDH/ljxgFnUagJsHJo1NyXE0nyBF3TgwvIedCjpbFtKZjtbV1lEqaukglo5X1fDWYKzPVMtJG87cF7efxnDOnLeQVC9mG1ahtK4eu0j3Z334AE7dBwCZEoEcGm9D@XsbM1Gf0fD9zFMix@Q1VTqzLOBKcLZ1OoD/Yc3U5QshuLWsQAHqVpIgdA4pEm9Uv6L/iUeg1@JjhcvCaQ@AZxVQ0R@4Klmm/E4p8jgSFtgovBwRbdqCAAnIKF4xh4DYoF/nCHGuXcVZCk6Mhq3US7Et5utAuMawY55DpEolo1fU@0WH9jJFpTgYosMwwuGoDR5NwVuri5s82TAs238Kg@fUsCy0qRWNEY4fQEeGeNMzgJ7KdnE8DbhjkTRFZXqHztbhAxqHArqt89e8NK4DdTF8yYJBVar2RtvKnBYJoeUHGMmcBDbKvs0W0IpcDvCqZy2VBdREKneb6gVgKi4opfDIrS8RVq3QY@6RhJItmsZpGHyXtdM0vKJEjUis9Tzkly7TWqpDh343jFiBK5octFzEts0KQG6lfwRkjfwrNDfYYF4vQZsQprCtASblhG6jRr725XxULOA3AGx1E9cUWmS@qqNWwW4DaUL8YEcY5@Qy25l3nTySfJuEmHyST4nhSc71VBHDkLQJR0YDvheycdEtioqPyCV02ph5uBbSztVnR5NGQy7wTI2ExUyJ22TpF1TIMPNRQUA1O6YNhXuiHAqxJySLVXAJr92B45sM3AKuR6C4dSkmU7NRSvWvSmcKdxdftXk04C8aJTEm97W79DYYhRlVVlwbIso5/ukJ5LmVEc/5rwojoC5maMjrSJYncA2TypBrPEbsS64xIyhChMMNDnpuqREQQ26Hd0Zqy1tCeec5epESEHqz3qawo@LNDdcOrghexNpqqdsiyE1wSdQyt5jJHNSLw4Tj12FJW8tjew8wvHUbpudVPI2EXulOs7q0HsFycIljFdYjWMfZ68isoFCy9KOPGZKK/TRGCKxkdtHDwmaIjXruTvmtcT5NTSk2bnmU77LGo9y7GjiEYsSCoa1@dvUgsjrXphIxde0oyQ1eyNlSRN12DGlkVXv79RFkaJxsjWoSol11u8SrKd6rnygb5Dfq0Z@1OG19AsH2FKw8B0XCrMmAtVKCSVYFEoDgjvmNsAIyXpCqW2oxO/V4u0jFBjxn6ROtCoZJ@9DJUdSWukxMkT5NYdSspclkyUsrdLFDfWAAQTIBafjo6bqraqncI6JbTUUtgZ65oyekYR3BXyuXqdkpeRmqrnXKdJUPc83p9dwKkm9zSEDwro0DKBqyptlWEfMTq1pSzOaayQR9mBQVUqVCBAb87FAdTyHY5sz0KFeY7YDNhcgrxUVT3iZLYpIUFu1qtwyvYsVUiBI3irnHIB6y4qPOHPggb/XwIN9AN2VAi3W651G2QXk65rKi4FJjZao2xEznJQyIOpUc7j5HI2oRa0iFz7IRxWtjKyhruFyE2WEBBX1lbwhLQlc6p4KLE9vKlflSB5QWiiZSE2faVRa0VSkGqdoOWdlQP4jx6g3QKtFjTmDO1A5DbGqEjO0Uic14MpfVxdoVNprLsNnjvhmKji41GD3RBwb4Kk2suUTWoJf6vAUvLlqgEGtfJnT@4bwdLAv7ZgvJmFb@hFPDsFYHb5l1wG8@FTYwoqW2hYlxg8URVaoVx@CFXqoi91qjCURlBnGe/jUs4pJ6SkAp3M5TaDA@Gd0nIGgrrFX@Ylx4E40Wtaty9X2rdleMZ5o@EAUrF@jOVuvp0jpcJaUop4iWVKFgCBehEilU2CPGoO9un9AurUZIu8yqQFKgKUUw9tqd1p9WmNMArhRiaZ3dJ8WrFL7qEElhY8YSS1qBR6zRD7UNL6k8OnjWFKNmt1K8EElTalAMaAQoVqqeCU9lOhcZXuf0kaQQY2PknFgv1GuQpqSCKEiJNK29J2ietX8aoAlUBJBXD57W6Co5j090AWSoCqnG/NagJfuOshY0weEq9ReqXYu@cP0NFppXDtokPhLqW38/AnOR7JTDTcjxqRTAzoUHt4VJeNL6FDfJ3oqGiEWnESxLg1ZjpEeB1GX3T0pIxqnasNIlYBMz@GxTubVdmu0hrIGPJuXeTErpmkzkIk07mNcAEuVi0qFc0FxbHEjm6CNcQexfJGDHmlcymAqj4MEmp63GagRg1jFxs5V9lAB@XWDpB4jMeJ4gSd0Uk8@mYKmEtRqVXHiA7OZL2QdyiwhwmfpemoaG5XaGuvRJYjYB3jSNB8yY1I9Gz9fGPRESg1l9VTUr/cB6UzoW5bAnF4skj81N6q2pyuUQ7xS2ojzClC58kzwOiZFuuYxqyamrOi2fglwU71R19WHI5G1E8TUEsX3UjQPiSCJ5Zq38E6CBM6kCwi4VvMqToOYUimPUqIUoYIl64NgMX@7VN5oGtb1dFXg7Jw8Zhl8afo@SahdXqRrxADAUTfQg3INjVNUjfoM35bGjDWgAin16ka9ha0o9OF00qacG7u0YGBd/Eo5Z48V8lmXqpxiWNBmObvaVvGNbLlx2B2XmJaQ/gP3G1Fb6E5G0kBK0B3px1WzCo9dsSwIVNo/ildh7HTpQpcmKX3QkrOpmhLIXnzMIV385Bljq7uoBlZ2DJTcpsF9AtB8ToOhkm0JLy/7JJWpskyRKLHkIF@ZvuxNZ74IbdANFp9M0SM1vSbtPeQGcXyNmbh8P9WkFtmkTKteIDW1e9U/9JFFlTFUVfW8XVCSNZ01QmB1nAY/OXvl4h6JEQ5mEp7neyASkJT67BiRJUfB686Bp6leEtBB7l0@qNUlC/L0Iwd4Jd1zsjLFk4V8FNo4Ir3YLSvrDqyQovGWpkGWc5w66U6WODBAH5KgCmTNctqqYbp4gF0uKDna4sQS9cE5SgFvhYztoak@L39JG0p6@3xJsSmfrnknL/Jsjp/N2AUDm9Qj3fAem5L03jq/AD81ihstiJx9AMCHf03SgitZN9/VIN1QAsjVCveJ@CYuBK4Xjx5dWNQswjplSNlOtUYNTb0nrUIo4jJL1hCshlN23C@STinGtjRy42qCBgKbqg@/OCHupUkuxXCwQEhH16iQjxxqPo1tVF2siRuCW1OvADe4YDovnJsz1y0nvxeheRCQZKg2cJ6ebIxetjgvfGmqcevyTkyrd5EGCD3f8HVSFGyb6d6ea9rS7UjdCIxxvqymnE2qOLGcmk8S9lRnNjbIgnt2H10QrZzqKpIXRggvc0jXiMHybKN4qVgjyiu3qhEOIhNu5LNfU73ybbfOPGg1MTXUDFwp7pAME0eF01EnTXFPqTmu/o8iVi6kKd7q1myD7njEM4fm4XX5LO5JwJd1GUZjA94s13RTE8RFS1i3L8dUzyHa67o@MqEHmhJPpyl0A8wosdFEFRMTUIh@e1atMZWDjp1CCNOdPglXjiVVxgWN1PewQwfr@PP4Wf2Ujj9wC5zVwIek2tQhEI@x8Ygh0NbNw@ajREvTsuqKhk6gayhLc4s7JkE0hqyRvhSdFPWLi0T0GeCgBpw64OoxRfdGQwCaNHehslqLmSwv3THmAtRHthqnxy3Aqs7J0CR4DaY5lEz1zMA8Uti06dTp45SanZPSzJn6FC8pDx9YJVItFqGcU4I/84vuQw39iANwzALRdGenP97TpczUFbloEiVdiFIHjawX14JEcsrjoDfEfWtEUzPyvYXQq6uD7bHu0TVeHttHjKFRdqZqGZoQccxqUGBpnECp115UPuo8pXNSQ/ax2cXQjLYmO5pVILPEjY5sl4/i7pA6h1OZMnrbSkJJNNxTkO5QSJCWp/lItdKwTWf5TQy1CaGz1Vq50aJPmnlQi95YNgxCPWRBRdwKUqtLxzHj5vYYdsH0KC5VSMpURz1FglDy1@R199sGNjOuAS/eGJKsCuGpWyqRvZcJw8Csf0HidTJRi/hx/W4t@bZuyji4aM5AEyuQVJ/@6ppeBdxJOT44J2GjuZahRXWNG8PgUlwWaEua@TZp2sJHXSxNDEVWE3lfdm8sDheQUE9WZbKnH11KkshA5o3bx9SA4Kyuo/s2BbJbERm9IAkuIhn7vPMyNVTQVFfEGI7EaSKknjfHlIl5Bm46Y@gpqaEt3bd69bL1Ek3cKrW69A91SlPDdFG@dE37a/QjoiVrRmna/UKfrJJGKzgRKTQnMalKE7DkwW130gXT0iUcZHHCOlWJxcCz5BkV7KzCL9HqZn7XlB/BYpINKCARFrbnCUvdHnCjB5EV3AIBWSuIqTab2CRT@MXsIR0KAKihX@rsNURDneOSMPCsTkwN/UATVVpPeyyBm8206y6az0mQBPitXS71Jrz0S4lddvknaoasf2nB2Teedul@WRGSzqTJrvSBy2NqXJOXVX4@Jk1dHcw1JmaaJWqpK3FdBCvBW8Ae2MDw@NeQTT9DY2dr9ejOno8wUD2upjIxJoG22EjRlKoPASt7qQEplC9xPZXg0ARDVOpAvHixumTT@YTdgC2mkzi9IBthCbzjJFqEoqSuuD0@lYu2Lpd47GEXgeeKXraOQZ0Z3eGb8W9mECSpCglOpJvE/McK9lekB0l/Pnv2mqzG8EOFDS/5@NPVxe9f3339P5cfrv7z6vX763fHq/jvt8fbu9d/O24@Hk@ePv2/f/vx4i/f319fffPik@f87duLL65/ePjy/ubN9aX92zE@yy@f31wk/d1/fX/z@vryn/7w/u3rm6@vHq4/v7@@/uoyHvfjv9998@Pbl3rD3z3lxdvnz57d6Ocv9R9f311/e/Gv/Me3N1/fXN8@/Onm3cPll6zu9u7NzdVrHnJpT/jj7cP1Pau@eri5/e7nv7@Mtf6/TRw/@JufPuUR71@/f/fZv7AY/u@Hx9f@9er1xef3d2/@cPPdzcO7yz9f//X6/t31C/0VX9S3fvG39rB/u7u5vfwQv/0oppl//MvVq9fXP37@@u7u/vLmn/XRy@PDje1ef/j40n6p75aXz/KTl79@/uTVeS43nIS97vbw9duB3F588ln@exvbMz7cHm8/Xnz1/u5Bhvrz9Zurm9tvru8vb/3hz@1LN88u3j4Pm1/Yav7BKR43z/KjKWLv31zIzN9d38emb8MOvriv3l/f/@3ik2KWuXsdB6MT@uTTX3zj2SeFn/3azW/WuUzHn65vv3v4/sUvvhae8cu3yydkoJ/8X7xycfVC/3aVJyz79uHyV1/4v43lx4unvzq@eOFfefnkH3qv/dT/JS2Xry7962Hldy8vLi7i@y9/@l8 "Wolfram Language (Mathematica) – Try It Online") (pretest)
Use `InterpolatingPolynomial`.
Due to the [Birthday's paradox](https://en.wikipedia.org/wiki/Birthday_Paradox), this is not as efficient as I expected.
[Answer]
# [Python 3](https://docs.python.org/3/), 1.873x104405
```
import sys
inputs = sys.stdin.read()
numbers = [list(map(int, l.split(' '))) for l in inputs.strip().split('\n')]
def encode(numbers):
output = ''
def allNumbers(numbers, a, b):
nonlocal output
if len(numbers) == 0: output += '00'
elif len(numbers) == 1:
output += '0'
output += bin(1024 + numbers[0][1])[2:]
else:
output += '1'
l, r = [], []
m = (a + b) // 2
for item in numbers:
if item[0] < m: l.append(item)
else: r.append(item)
allNumbers(l, a, m)
allNumbers(r, m, b)
allNumbers(numbers, 0, 2 ** 32)
return int(output, 2)
def decode(output, key):
output = bin(output)[2:]
index = 0
def peak(n):
return output[index:index + n]
def skip(n):
nonlocal index
index += n
result = 0
def findRange(a, b):
nonlocal result
if peak(1) == '0':
if peak(2) == '00':
skip(2)
return
else:
skip(2)
n = int(peak(10), 2)
if a < key < b: result = n
skip(10)
return
skip(1)
m = (a + b) // 2
findRange(a, m)
findRange(m, b)
findRange(0, 2 ** 32)
return result
output = encode(numbers)
print("%s.%sE+%d" % (str(output)[0], str(output)[1:10], len(str(output)) - 1))
for (key, value) in numbers:
assert(decode(output, key) == value)
```
[Try it online!](https://tio.run/##dZtLj13XcYXn51ccGBDYbTPyfj@IaJhpBpkqGlBmKyHcahLsVhD/euX76lzqZcaGZd2@57F37apVq1bV/fiPl//@8FR//vn9jx8/fHo5n//xfLx/@vjTy/P5jR@@fn559/7p608Pb9/d3R/H008/fv/wye@@fXz//HL349uPd@@fXl6fj18/f3x8/3L36nx1f39//vDh0/l4vn86r2fxlE/vP97df77oP59e3X93vHv44Xx4@tuHdw93t@fevznO88NPL9zDK1694pMXvX18/Pfrgs8Xvj7fvj6/j8vP8@nD0@OHv719vN0Zf3v/w/n48PTLc89vvjnTm8@P/gvPTulVXPjw@IVL8/Xg83c3vPqnv33//ukup9LOv5y3u79N332bv7v/trz57vb054cvPCt/ftbj6/OTxvzuNf@7/e1H/nD3lmd@f3/@9a9nuf1Zk75/efhRq97e9vnJsV2/4/Xnv54/vuE43n78@PD07s6/3v9yWSzn/PSlL39j48ew7pe@@cSftftxfvFM0uuznH/@81mLV3x6ePnpkx7wcndtnW9xIQ/03UOc@uc///3hH78/eQ17ffhsyvdP7x7@l2/SzSU@Prz9@93TzQFub7ru@DYufXPdwMF8d7vj@e944NMfXSYuuzzmuuGb8ynW/vzT48tv3vcDX//H26f/erj7kuNdl392vFhbDkfCaz4f0ucvyu2LX785r7WVX8/p2tDxm0P7fy99YpGa@Hppug8j/8Yt3uIQ2Jd/fv/m1209/f553Peld1/fXV990St/Z5Wbw/z6t8@u8utfvuggN@Mdv5z@HzDh@PjJDf7pq@evv3r@t7989e5P51fnHYjyi4skwue3n/Ob7J@M6t/8@f78lzPf3x8G0h0meX3@z9vHnx7u/xBQb5@fHz693H3BRT2365aff6457d5STvOcZR65prxyG22fa9aj9DbbqKulsy8@zlLb3nuOs/XFx7VGqmvmc28@rtJmGrWmM4957LW4cadxltaPuhfXpNXWmUs78uDmOtKY5@jlqK3m2lLP49xzHYNVpZZnOnc/ym6jjJTyPsdMR8k5rzJ3qefa6WiJV6aaOt/WecxeZylcc67R@bKPUVhDO3tdR@aZo41UztF4Z6997MaOTzZ11NobduDRZ8v5qKO2lXMvHbvsI6@VNw87e99HK7O1iaX6WSp3spkx6p77zOvoI5e05lwn2zvYem5trDrZdjoqFuxlsb0Tw7i1PttebeJJgxWllpomP9dRfQZPre2cg9XmmrFYcduteSf/GXOWM7d88FVudXIAJ4bh2Lizl8q@eTwfU1u9F/eCUXItdXjByZU17zHc25k7p9R7KrPnxaHl5Bo21s67cN48pmC8zo7OOicGyxzYathkxApKwjC8srC@lXJd2KWeHWO2wmHONNl2rsf1xUj5HBhv4HoYtXLyXFnSaBNLjopL8Zi2y9i5YFn8La@Oe3Ga3FnTkVlrXyvVfHLi2na1yv3sa2H5juXxIo@MjY2Z2xwccHxcu@@x0@rnCqfHM8roethiY7j4WqyYGOB4OVxu8YzywIUIDi7HwTo@xFGuja@yz5wx9M51cJx1nT3xoJFWqWwmsVO@5a24Mf934iNHa8uLi18ON86S0uRUSscVVip7pjzdaj0WhzCwKU5VsMPk6fjC0P@Iu7x4bGLZGLsenEllkYlz8JB2KbsvXJX9Y5Q6GqdReI6OS0xO1rfOWTFgxhs5to5PsaI8iBW@5@KFc@bZMDiOP66tlpVwKeyFizXCe5fNDnD7nZsntVrBisQhxzjBGEyGQYd@NHHbDEQMPmJ9Ipj/dg6KO4n0Ndhc9q39yBi3d56@z8mDchmF4MNjz5XZXfJF1Xu55SD09yKqF/HT29Fr2gVDEVyst/IO4hCE8UEAW0lEhI4@iS6N39cERQjeYw48FGcdk1fyTqzfN44tBLbJH9ZanJrYxMuJ2bKw9jpYDDCFt5xgB@cCYmD@dOLS@kYnhIFBogeHFATwfe6sRgihtDnRXXHeduyKV3MWZxVmMY/guAcf80Ew86lx@J52Hvh954gnyJkP4jN3A5xtEZT49DCgDTvCvxKCC0ApKQkDmQPnf8QWngyS4UYtEWoJU@J9wMvwPJtLYO2ZF2D3hQNy2on9Aygc1jE37@A8WRFupPvpqixwT08b3MB8XAo@dw4Im41y4r2cX4nAA4JHnxhhENAAGGdkjgCziQgiAMzdGBPrEaI7ddFmc0IEDu7mXhpPxVyTtfLQhmO2yEpimJi1ODtwXUfF8gQWu05FI4AkOdwAEMP0xMZmWznidSxiCxMI@iSLQT5gQdwpNrLilpbJD5g5IiPx1hreVg1CtgLA7O4hgVIcJysCX3ZZ@LyZsAQyAcUkk3BpVk9OJfPgX1Mg1w8IqjyJ9O4xANiJRbmGOAdAhESBZ2xeg5UxZxYHiCsSI97XWQOGBwWSwV5MuCx3u7gm5HHu3rlL5qAmi2BNxQ9ti3mEAObjW3B1Gr3cBiBznl2cAj6I8kLgkB1wecKvYLJ2ix2wO@FXBYARD3VNDgVfEKFb0yFB@JOAxviF4Bl6PahutmE5gEaNVE4WJ5yxIoHnCicmA/6BKhAQ5CqiF/iSyNVEC64szJI4WdEgDEfH7XkMeA0@4Kw4J@fCia6pbxgScfycEI6MSeUoonsmmLaIR5qMjDyDC/FG8usGX08QgaSBgxY5A2kCBwBCAAfIDwfFyXBkOF4y55pw5jTyXP5YJnOMJpri3M0cw7UuOYNqiZDpo4EVrN@NA48kCNYGjnGsRFDHyIAcQCDINBAeWgHuRsaulcPEt7q@RVjitECrGZu1kk5Z2LpQGdZDQp8erNSEGxcLA5CAycMkRuwmDAWNEfNYFGsYYjRJoCdew8k0QorHenKdjz4nYXtSs/6SRew@wAssXvUXHBT@0huHDAAYmqRQQdFEe0w5TwvO0wX/KnTgvuAgr8VdWCNLuRCLrE1mZpGEvVyK1xr3xBzBQNIFwjg8n@zBYwZOg@ANYoh3QING8IwauTh7HNAeaRmnAMGD3rJ5HlVbTwsSIq6zZoKYvZN8yTQHLAcrbXgYyAB94W9NTJXMELhGYSNbFWNOrJnVsMIsUFgodfBWroR84JuEMqfaD3iTvg7ysJ1DEtYA1RFJWxcG6rZ3JpIDK5mSSLbJK2CUuDC@ifHlT1t23oJUEBn4CqFK3gtXIiPj4UAPoQxuUhfgkixDksHFbQvcEH4iG8fi3/YmL/4ScZiv4YUt0qe2BxlOXOQA3nEt6EHQMph@lcEHJEBsRD7z/ymMi/bQZfilnwr0FuuCk0Myxb4zcJZEmm6@Im0kMI1c20wIxiZey6EULTZAHMAYlzVU9W2/pBrgPPsupKAtCypyFTGWmGZF3AorA5Ph4Kz0kKm0BU3DmYVJtsnXuDqGIF9B4CSyiTuJeZxsks1mlE5ENwHUDCAuFRiGVH8FbDbCjojkXIFfwxZohk@BhDxdrAP3WOoIbyAqSB5Lk1FJsHNYIo7c3DnmZUlgj2sAlcSCTT5KF8GTn2AJT9idVvyxyzxOOQ9HSgHGuyMyIRKwNFJNvdgfvI/4p2Aj2Fi/5ZihvC8CAIcilUzyEvHs@iep0Hpjyeg4/IabFylzPzSQ5ieHydnIqjBxvdlaAEfZ0lDypBgEvcQp2RnxjmcMiyNQEuA/jKsc1A87kWlIRMPlmdRHpAfxlPyDx7Fyak1THfXOsBoCFqMUgYHPyiHi45gAzxa4CddIKiAXVxtLhCLZtXnb0G1MmQlSkiUWJzwLagRbNpMROkC1OX1EAagxKmcQiUtOwbcJRCGOtvhtDdOsvgBX/D/chDSWJBF42pDXX1WdkMz7gFZCZ@q3BDS@VaImgCkTzGA7xW2LehE0WSarJBUYZhULsIhtmAzWK5ZuPqnKBoAGQBk3AUghfjJuF0hc4Ndij/VDliZiZ1xm60EcfI1yYlsV8yVOj/8BlC0CgIoai0CVcSEoGhWMJc2MisFyhrNn@UCIRyntWHJ39jolC1ALGF2JAgIk5w8YO0s6CBheVXeUnlzKs8klsNwgHTiiUcCh6jZbkt6sApZVIk6e5LKxKPC2GDFFxyFbUTs0bMFbGyZlP6AlS4YOqi2QXU1WJVgceEKalkdKbUjSKQ/dinRLQBM6@D8uQPBa1dYZaMtpWP9yLiQEsLRaRAJ/SxAkGWXTgtjUzTbYAf@TZwtk4REkKbIT2b9FzoajAG6kwGxhX9k7i8Rht9l/BJD5GlCKi/EOUFuiOUzhVlpZJcLgIhjwB1wKxsdOTcPk/hb@7MYX7hy8wdoAhor/SFfgJ1V@DxMjSyu5ZN/RzTRgDrdudSBSIvi5jiBxuDZIZi2QFV0II0myJTq@zYKG2o18X1/Z4oTV26ZQBfR5qu8EowkO3JdI5PgJL9LVvlIg7yRZ6M16kmgP7EF8o@KgCsPW5MRwUV8JcFAjcaQ8lugyyVkOQLd5Gq6yFEM8YnjdMuGweGqOqRNalOPNnBMZogLWWMiAItJwCKAtKnLCX8D0XIwSoI8UF0Xi1LgmIxjMirpQuoY7mr@p2Cii2Y7YckkcWx5G4sUbwGhSKtbcwSrTxbaBiE5iICOS/0B2/kJa4LGkXp9E2Zp1HCKL8yUSoiiDvICrbF5xiXSEPYY7BzGXmWGrGFVxMIcduBgqhucQQXAgKRrngW/PC/sp46zmZUeN8skcT7hRYGUcDEiF92AnvY5NEtrD6PNFoBfEAp/UWWSJnNa8OFqVcST4HZ9YMWBr3gO4lb/gPCtMjDNbaZN1Z2pQZC1KEkmWZyX0BcyHU@HReouEtEitpfFFnU8hDKcE0diCZRJlBBZlN7iSqwFKhil9qcIIH3qAFTw2A3Ct8eAxzdJGvyZoMR71Ej6JcRUsfRwghEVirS0WayaV6lHzUNly7lGBQj0F5mRGsBRoEkMrhyAc1XOxMuc9U@/llAAkUnYIKbACWFvoQBSsmXRAelNgiowgNkgcgbrhEociVw05rAifEmh8ZYiY0jKF0aFJVtW32d1pIPJvIJdSXjP4N1tlu9hETbUQ0KQ1IDdwZA29dUOBUvgYacUip5olCdNZL0EOhITPqCZ7KnmKOLivbiH3wOmmrFViCtn0sLNFmlnGB6k3cL6We4ocEHcw5pY3NALnGjWbJHYttdsezAkDC6Yj8NHsj2eqz1gT8Na6VSOoOaLuEs/JjNCnYFbYmYoAxKq38FKaTfGeFGG7LKhZsXI2YG5xqobFW6E7ZFsBXfnaVEU51WQAFvwcSbv0mxrqMfcNTr9Z0LNg9j5kieT/THCAI3PvyKfVqovam4sV40naRC22J0rLwvpyCyl5N2/MYLJZyisayJ7UEEdkIOzjIbJ4yjoVRPVgVX0eW6WwdWCLKPC1Ea9h9aVFwicJk4SgU8vQgsFLsPyoyXCwSPA1jF9lPg0DwpEFJNAHjhwUCqgS/k1z6pKJh3OqNiHABfa5FR1alKKKvqCqMnlot0kSDsBik2rWmKEM7ahLVLYpdXOJVGAu8hD7RT2X1Q10no3tsDwoBxas61ws9QlGriB62iUjSJ4BhpouxCEk9F7eQ4k/2whyP7YiDRygqNTPFCUuT8URWRL8z4Qkd7bTwaN47iSRZkkOF3oKEpdtfUtOIemoSgeNJtKg2WpKqlHEKN7cYwXJ5cYZUsVEfUEq8uqk4trM552g2ypkJRCRywuIyZJqdHV4VddXtr0ENhOrEO2tvy0UDQOwjZqA2CemMRNHSqHBceDa3fRJMmKRkMn4CKHi9E3/WjRCxvRUQ3rrgWUUlJZWxfRFzoBXBTOuV0MjWVqlkIqAQCHJLpVFGqtgt1RYlDmYZklmdigOPhheDvWCXS1lTl4LeAHqIGgsapA2cURqTCwxQsiwrKlejPuwhx49hCjaJoVtVVpXJYjcyzrtaM1QK5ss1N2XA3@1v0S@irbatq2xLF6bajmMyKSpxS2fjEQLWqVYBXHIAlewCsUJGzmFokTtSJmM5LxMb@vm09nWS9Oslm1NmOdVHLyqlD0E3HsosRHowjhYafCKGHJblgidkPhXNggbSjLafXOwSJtbug44brWGEriViRveM7uHqzamtiKFXcFDAVneTMmzAl7E9arsIOWuquTsb84AVlsoXFXEl3ZAP8DUYs2/rIuLhUiI/yHaQP4JdVOPAgWkz94G5MFuXrHHwAWXt9lkknzMi0dhIUKgXsKS7TzqNQ5Xvmb7DHhOXGsvpqsgd7tXJNFLZsWkNlhKUQw39MAFXH6qN1MKwh1gztuGn2KRRcswelwykY@fWu11s5PN1iFB5ewke5BwoxK@ab057acJFXEeKvsmzX21YhsprllmkI8sVeypcHZrBgFt8nHSK9vfVBjBKSlW8iUoTnPwsA1V5C28Itkcw26h9GO4Fd4lUsAzeAr1nlwJ3FaoMEPuYLlDxRxYhgXJRuA4xIN1NsuvkdHB0FPFey4RnWgQH4HrDZdS2FfmU1ZY8vDAFBV3zQAnt9E5lJ6JxB2NxCLiQeaTlastP9bAK3AWuTzpHDrHcjBQtbUFBVf@nopd9k73FiO25YSdIIKU1G9lB1pAOXoNFYoDlzFSVQTNKgpE2SYooZihfdQMMxQWdR3oIgxxjqszUhWbIZCCNhzE4mhc/hMVGvTQYOy31jVlwJyWojzR@sz@eEhNIySWaXGy1MKEWvvl3aeB0kaRAleknKtfY3siR5YOOtVEm5R6kBc3VBRErgb1tG4nWwpNNqG7TJpoIukkgfiS3foV6INQSdOWSFAZEEKhUBauoASjtbNhe5YdVAJX1o7Xea5cS8Q2CzGTJDUkFEBJokULXfE3X2qo2gt@m6A@bEAFCdt4lCpgphJFTRgA3l2EQAwybIEHjSP3ctZcAWh34dJK26ZmdE4lCyUkUNXHHP30aPgAv@p56kFsziVxPaiWNGKOyJCxcARu1uUrboTEFOLMjD6SuEU0HdOQgwNZmamlksRtwY44S2v72aF1itEhrS41u1ujVb0rGmakvvjYFJpa6DrlIBzNb1GYDZt9qjHgqo3ebUnseIDMZ5hRi70hkwgACNzB9PEH4cFS1R7fueLGWZTPCXLhzukFEcLeo4UCkbmuzlaoj2xMLaldInyWEHSpO@RBJmkjS/mOJymNXzIstldvHiM6COqq1h45et6UUlW2rUrJsznDHVU6DjwtDBUj@zCP5WiB@NyGf7LtFpeSA6TX82qmSJiaDQlQdCghC7fDKDIeOd7qiwspXPhQfTBTRC@F08YfJItFgqqKADBVG/0eWqo5OrrXrAZcYBvIuq@aWbVZyDECx2axMUisnO7l@pxcl/Cn0J9tlpsz8MHGWzFZkMDo30oUWCD@R41UbLPnCBOwpwU689AhUKUjOnLFzk8TUnleDD8QoofdmqmysEIU5vwEFjD3SlnCpmog8cRubdp148TulKwHYuNoAkRmX/2mZbOcdG1mAY5hYvbNFVoxfJTAJUcTmewb22Ev2IiUiqvg6OWykf0NQcgOU1SrQJScxwJKEsaT1QoJePVwS@JtHUt6IkN0pwWWHWNbI1nNkQxmfNvMGR7a3jECQEQ70yOSs5UoKyETyVstbPGIUCthNHimDfKQFzAYIeBroy63CbgvTTG0CKBsQI282Oq5KcPUGHcIGBkCrnkxx6gT9KhH8TClTqSzZqmdL@o0KV7YjU3cHImxW0hGLLof8hQxJnPX3BZetlNysInlbqzjQoLGXBvcYNFRUXFaMTPV7fcOTQEjBcR2zFQZ7RImXV@ysayaQurqhm2OmRIDoYeIM53l8ASUHVjhpsyirFPqcg5hkLBtFts8C8XXkZ4g/dVsMXb4ugwUSCetTPt/MVkBFQdQZo4ul4WTvYo2r2RKBHC1nIJsOqOpGgWkU0TqQ4o1Do9Qp@pPLmSJKPIyLQx02xES2vG4oj6C8wXLYQdSg3qJYxjI2ReBINv7ILdQfYyQ5FS8QPplq/0GctMdtbB7UgRnP9RT2a6e1QhLVFSs5HExhvOzIGnE/gKwPe@pgmOTm@ho5LrRQ9CjyMk@bcekhCzU5r5TKM35tBXtEF0wGg7Eh6Uj3x5t@nrynLRYrdMZICUQ3gEpbqbPHb3ZbB24U5cKhGS8HcSCyF/VncLftNfDx3SQ7aotentJJCay4VaD4NyVb7ITNErIobJJExyn2dGrJUqVXcQFIPPgPptJfUSlba5P9rdk0JLKIelNgnKP1j4Efw5TlaR48srliixs7TQRlCRXbO1IlV0dldZrJGMrs26b8HOGHq5QaeBBxOx@mqpaqI1yZFWsK@s1KSCsQSmtGbIQrWXTUNau1M/e5Sq2u4Bo531IGD1YQlVtMNmzfMdo7LyMC0fkT8MeSI5j4hDJAkWajm@wBHzVlk6V0s/DGQrIquJEufqF9q303zg3ApTvbH7yEXqmnidLswPirkGY7lRLjA/ZOlbxjfklKDR4NW1ANXvhptZaTa6OwFBxmakcpRhKB9BZy2f1cttcCoiqL9J4k4HFji6gq7soEFxhm6pBDxVQHCezmZXNFfwjx5ghEOYSqCUjf8LRh7yhxESYKpGjW3xVLcIt@uzHOhPANVS/WzpncW/PmnCvMSzhdISwRq2Wgt9VW5q2/jSTXQ0YJBiTdszCkcQCuGV0IcTZiVgxSGoBYxCR/5cCbonGpB4ehVx1tMvYtSvWaowMECYZhnY6j2dZYvUMMMlP7C7DQWf0sgj77jiXpwxj68RHZCRKQ8mWc2nm9xC1SZehTTsxJm8nxZGpUwreTkKBBRO/kmC1FENs1BhKc1aVVBSdfrVz2zA4fkoxPmjbJeqbGs1SwtwCwOd2Z2uqWgx1jELiiLGrYrvinCXyhnOdConTYQh1gBbzq44Q2H0mxZJGQzuy8AFiS6jwOd4g8AaxcVgKrIatRbEDNUiSGz04Upm1e7HawR8GcUwyFkzypdGDUc45GXDCEIjFGcWkBFDhLKyGmA61VdU0lRVFUZiLQ0bBBiPlm7NLbePzZxyGxGB1MMP3VfwIdqivnRmynyWu2nZoyY68GcpRzKnMebDpNm61Yta4jGjcKDxbmUL5YJySeuog@UVI39nRpnYVDzGX4UQHaEBic3yCkK66lHqJEs/YsoCYCIvmp8zTJNkjsanYpHJrNTqRGTMJIwYhSow4SrXh3I6nJrsf@LDxyllSC1tJ95gUWErsTWrsCFjmy6yRZwnRMqu72JaCLmxb8Y7IxnqJ5WYneMY8ZA7uuDDUhUWORPRU7PE5tkc9OgJpMZOlBxnGOSnbLypFQ25kPWxeBekqTwIBoyPcnUmqzi4c89KKCfNqY6HbOwD42wUZtmXwlxStDbxbmdFuqwqrAlNyXBWXaNYHDiOpFp2lBBWm@iEDghcxR7Yk1c54qUJapbE3cJ@ctpzkTApiyyLOBiSBbsfCMFnDhmq1OT9cvCNxtp4hVHJqFddtZDgESWLRCdl1C3bR5Q@iNREQgkdXqUsxWhNzTF0RPr7NkUFGzDFHz9S6HiYzguE6n5tsNkdyV5WrdjBvun4WaEyBZ5Hns5vlaL1TRQ4cYelqLzFLf@dQU7yy7Nj2PRTjs0ijNOL4J0GBnzgKpTiG21tKKG9YoaRIJlhogPCh2NnO4hJSp5PK9px9kHMhapVRdso7bSMrc04bX5IlioAqHW82luxuONAjfYa912setaRoZ9lkpEJw3InTM0f1SB/wixBZzH2AEDCklmeMZkUFmMo1gjBVyQlcstJySKIr1/DEMwdUJKfRgyILt3oU5GcENMfseyinK2Q9TrrZnL7G@5Iz8jI2IDOkGgsq55hYH8yMM4xx1JKjuYaXw1WvZipsC5qxh9MwlkzArulhXw8u0ZfvTiBYOsQsKIuOkdTOqRH5RNS4lEfKD9HJgbKQZHO@WoUOrYUgASOI7p81vvPkwKItNWctm1kfjCx6tj/wsEu5LkFIq8h2a@iQFMUCH0dqQZ0d7bLtvGMqXLVIHrJsmVtZOkLTZL8O1MornKAwnoLRkHC7TX0Hc5z@YLnVcen4jcV2mgsgJDL34S9HODdn0Z2ZtfNLFA95qgwyxWime73G7p332Y5hx0xkN3FCM/nWNUFQd8wU7iPa/f6CxF9VxCBMto0QHWip0XR2wIivZvJoTuNO3XamxGja8QBbRxTYc1jTxiBjjmGWVEJatyaotm2JFTiA0xbTftuOWX9DyNmFYcNipZgdHiFKiXzByafMyVpddXQUGaMRXmyb2et0zjeeNJy0dOQ/JmjhdQ4721q04ebEQRNMovHkr1LGVIWN5pxjw5Mk6WxiurbqFH7QN@iOlHYSltGry7LdKXafO4WA4e8jlB6M46rJQACVXw4OTOHT@Kw8qXYOjhXXIuRJOU311My9Dis7hTvVUXsVzn/ZmYm60bHj5VTPjq6v43IOw6RQkO1IFaXHGeFp08Bemsp56NS2C51rVC6q0b4i46kBRf/QPlXw6h6/pahqxsMZxBpMaZhsfFJgC5A/YwJrOlrkHIrKHWfjFBrJgVNcJdIQ@6VMMN1d2OzE@vByTCpGgB7OX/fbr48oVvwRQkjgyZF11X/yQ4x1m9LLbcwQQrkdUnL2srcQ0vzpRbsxbX@YxMP6iEEPSpdUI2/hwmJEg7CpMQFUsnu4tmp6ujq07j4me0IF2PZyWzDgWWKuN8fAeMx929eYZpPolAneSZIodDtZq7infzjiZ3qK2Qjncm1jQMFqNI6isZfsgNrYgweSQ@1RGaox1a1gr3ln/J5sjPh5zVksVRWT7MilAFnToFOACu1HzCk6VsE7QvyydJpOJEc@WyG5AWB@qQSYQpLAt1VY1tIHnYI2rO1C2omGXDlv0Z3OAigBa4dQLGnbVcf2ozsaBytJMWRKld@djVDkw7XV4@3tRw6QUq6Y2o8jIkjtA1lUCdsOkVtskpPil1PUFCCYP4VzK8LXNkZC67awNsXua6p52nRscttooivz4cH1mts3Q3EvTjVjDCHZHlNVq7Lm7YOdHTPxKI1CD9J0LCVoc3da1EZv@HJ2fmDGbzOcb1ALM5SlNxxxiA1OdpEv9kHszxKVqfCF29Qp049hPAtwyzne6s@E/NVfdzoGV6YkJxIVvOAuQryKNlHbg3wJY4Rh9o0xLRITS2CtPxkbqgkEYQ0FydOzFQ6zVmwD8FSea9SSzjX49nYrmlpMTTr/b7cUKOWe@GmNzTsVJGWKGN8O7pr9uePVl5rxo74VFDhdaYW1@1FJw0YY2coC5pZW/OlFrtH5bpG8rKNjUBgLkKuJeLLiMAZtk/fLdXcOOdvfQNjUpApZzZIj@vbbLFycw3J4TbS3KSJelvhRDs5rTzPqOMBSBqfGP82n8VufEnWxyRUMZ6ec7UUjCA5FivgN2xTBtwPFxgO7FppWdMY0qzq0v4iY8btNQUAOHLnf30LxjxVMpljjq@VdXT7n/DDlkEzz4P8D "Python 3 – Try It Online")
[Answer]
# Sample answer: Python 3, pretest ≈ 3.612 · 1012946
This is just the sample program A given in the problem, along with a corresponding program B, to help those having trouble understanding the problem.
Program A simply concatenates the (32 + 10)-bit binary representations of all the input pairs. Program B iterates through these (32 + 10)-bit chunks until it finds the chunk whose first 32 bits match the given \$a\$, and outputs the corresponding \$b\$ from its last 10 bits.
### Program A
```
x = 0
for i in range(1024):
[a,b] = input().split()
x = x * 4398046511104 + int(a) * 1024 + int(b)
print (x)
```
[Try it online!](https://tio.run/##PZvZjgXZUUXf8yvy0Q0InXlA4ksQD7bEYAnZLWMk8/VmrZ1lsLC7um5lnhPDjh074v76v3/@zz/@of/1r395//ktz7//8U/v79/f/@H902//8B//9pta2vjln573/Zff/sPv/pVP/P4Pv/7Pn3/zyz/@96//9Xv@l9/4d395/@4d/Z4y1qy1lvH@PZ/8829@@wu/8Bk/P//ul@fXP/EP72/@8stf/9pruXOUWva7235qL/XUscZ9z@5Pm2OP1c8o7zz8uFsf99693jEPP56zSj@7vvfy42ljl9V7eevazz2HP7xlvW3Mh4PxmXLGeWsbT138cV9l7XfN9vTRax9l1vXefZ7Fqcqou7x3Pu2O1VYp9b5rl6dxt9P2bf09tzyj8MrSy@S3fT979t0an3nPmvxyrtU4w3hnPw82qWus0t41eOfsc93BjV8u9fQ@B3bg0e@o9emrj1PrbBO73KeeUy8Pe@e8z2h7jI2l5ts6f8ll1up337eeZ67aytn7vFzv4ep1jHX65trl6VhwtsP1Xgzj1eYe94z99rY4URllaPL3PN1n8NQ@3r04be0VizWvPYZ/yf@tvdtbR334VR1944AXw@A2/nK2zr15PD@WceZs3gWj1N768gMvn@z1ruXd3jrx0pyl7VkPTqvFM1ysXW/D3zymYbzJjd6@NwarOOwMbLJyglYwDK9snO@U2g926S@xiMFw5i6ba9f@fL9Ypb4L4y1CD6N2PM8nW1ljY8nVCSkeM25btzYsS7zVMwkvvMlf9vJUzjrPKb2@eFzbntH5e@51sPzE8kSRLuNia9exFw7Oj@fOu2458z0JeiKjkTXE0OFihPg5nJgcwL04lz/RR3URQiQHHyfAJjGEK88lVrlnrRj61r5wZz/vLDxoldM6lynclN/yVsKY/3mJkWeM44ebv1xenCOVjVfaJBROaXeXur1qfw5OWNiUoGrYYfN0YmEZf@RdPTy2cGyM3R980jlkwQ866bZ25yFUuT9G6WvgjcZzDFxycnO@8@6OASvRiNsmMcWJ6iJX@D0fPgRn3QODE/jru2o7hZDCXoTYIL1vu9yAsL916KkzGlYkD3HjBmMwGQZdxtEmbCsQsfgR65PB/GfiKP6STD@Ly1XfOh9wjNfw9PtuHlTbaiQfEfueyu2KL@r@LX/ykPr3kNWH/Jnjmb3chqFILs7beQd5CML4IICtFTLCQN9kl8afZ4MiJO@zFxFKsK7NK3kn1p@XwBYCx@ZfnHPwmtjEy8nZdrD2eTgMMEW0vGAHfgExMH95CWljY5LCwCDZQ0AKAsQ@f9nNEFLp4tHbCd7x3E5U44u3C7OYR3C8ix/rQzLzEyAfb9dF3E9cvEHO@pCfdZrgXIukJKaXCW3akf6dFDwASitFGKg4nP8nt4jkZukAf0i1gimJPuBl6c/hETh75QXY/RCAeLtwfwAFZz378g78yYkII8PPUOWAd@ttcAPz8VHweeIgbLbaS/Tiv5bEA4LX3BhhkdAAGD6yRoDZZAQZAOZejIn1SNFbpmhz8RCJQ7h5l8FTMdfmrDx0EJgjVUkME7MOvgPXDVQsT2INS6JGAElqwgAQw/TkxuVaNfm6DrmFCQR9isWiHnAg/lJs5MSjHIsfMPOkIvHWnmjrJiFXAWDu1EmgFO7kRODLbYeYtxK2IBNQTDFJSHN6aiqVh/jaArlxQFLVTaZP3QBgFw7lGeIHQIRCQWRcXoOVMWcVB8grCiPRNzkDhgcFisneLLgc93q4IeThd//ytoqjNofgTM0fxhXzSAHMx2/B1W328mcAMv6c4hTwQZY3EofqQMiTfg2TjZ/cAbsLcdUAGPHQ0MQpxIIIPYYBCcK/JDTGbyTPMupBdasNxwE0eko5VZx0xooknifcmAz4B6pAQJCriV7gS6FWky2EsjBL4eREizRck7DnMeA1@ECwEpz4BY@ebWyYEnE/HiKQMakcRXSvJNMV8SiTqcg7XIg3Ul8v@PqCCBQNArTJGSgTBAAQAjhAfnAUnsFlBF6x5lpw9jbzPP46FnOMJpoS3MMaw2c9cgXVCikz1wArOL8XBx4pEJwNHMOtZNDEyIAcQCDIDBAeWgHupmL3jjOJrWlskZYELdBqxeaslFMOdj5UHpLGuXWs1IQ/PBwMQAImH4sYuVswFDRGzONQnGGJ0RSBWXgNnhmkFI/Vc5MffU7B9pRm46WK2HOBF1i8Gy8EKPxlDpwMAJialFBB0UL7bDnPCOeZgn8XOghfcJDXEi6ckaN8iEXVpjJzSNJeLsVrzXtyjmSg6AJhOM8n63jMgDdI3hBDogMatMIzempx1R3QHmkZXoDgQW@5PI/qYxZYdhXXOTNJzN0pvlSaB5aDlS48DGSAvvDvhpgqmSFxzcJBtWrmnFizu2mFWaCwUOrwVj4J@SA2SWW8Oh94k7EO8nCdRxI2ANWVom0IA3XXvywUB06yJZFck1fAKAlhYhPjy5@u7HyEVJAZxAqpSt1LKFGRiXCgh1QGN@kLCEmOIcngw@MK3BB@MpvA4p/upS7@f8ZhvkEUjpRPbQ8yvITIA7wTWtCD0DKYfpfBBxIgNiKf9f8VxkV76DL80p8a9BbrgpNLMsW9K3BWRJppvaJsFDCNWjssCOYmUYtTmhZbIA5gTMiaqsa2v6QbwJ/zNkrQlQU1uYoYS05zIv4UVgYmw8E56SNTGQeaRjALk1yTXxPqGIJ6BYGTyBb@kpwnyDbVbKd1IrtJoGEC8VGBYUn1T2BzkHZkJH4Ffk1boBk@BRLydLEO3OOoK9FAVlA8jiajk@DmsEQCeXhzzMuRwB7PACqJBZd6VD6CJz/BEnrYm3bicco8XjkPLqUB493JTIgELI1S0z/2B@8j/2nYSDbObztmKt@PAMChKCWbukQ@e/5NKbTfODI6nD8I8yZlno8G0vzUMDkbVRUmbjTbCxAoVxpKnRSDoJcEJTcj34mMZXMESgL8j3lVQ/2wE5WGQrQ8nkV9pTyIp9QfIo6T02ta6uh3lt0QsJhWBAa@O04kxjEBkS1wk64pKiAXnzaXSEWq6/DPlmFjySyQkiqxeOFZUCPYspWM1AGqrekrDaDG6PgghUtOwW8LiEIeXfHbHmbYfQGuxH/ChDJWJBFE2pLXf12dkMz7gFZSZxu3JDSx1dITwJRJZrCd5nakXwRNjsWqSAWWVcUGLLkNk8F6zdbNJ3XZANAAKBMmACnET8btAckL4lrssX@o0kTsTMhcIwjH97QT166YXxL0xB9AOZIAdNRYBKpMCEHR6GBsaXY6BtsZfM/xgRBdKe04cnfuuiULUAsYXUsDAZLzLzB2lXSQMLyq37SefJRnU0tguSEdBKJZgFMNmytJH3YBxy6RIC9y2RwKvG1mTDNwqFb0DgNb8NaBSbkPaMmRoYNqC1RXi1ULiwNPKNPySKkNRbrUZVhRbkloUof4JwRIXrvavoO2eMP@F79QEMDSbhMJ/B1BkGJULQti07TaYAfiT54tkCUiKFJUJ6r/SM2GowBulMBqY9@5O4ckYK/VfwXIfA0oxYeJDlBborks4XZaVSXC5FIj4tBExLH9sAxT@0fi2Ysfwjm8wd4Ahkr8SFfgJ11@DxOjSiu5VN8xrTRgDn961YEoieDneULiCG2QzF6gKrqQRpJkW3RimwMttRv5vrFyxQm7t0ujCujzVN8JRpMchC@ZiPtJL8rV/Uog76RYGM1GkmgP7EF803HQhWFramJC1FcCHPRIuJTHkl0WOdsB6DZPI1SOYoguhtcdCw6Hp@fYBqFNOdGMn6gQHbDGQiYUmUZAAG3pyEl/AVO/mCVAHyUuTeLWuBYjGMxJXyhdIxyt33RsNNFcR2z5JI4rD6PwEg1gNCUVa96wyvKxbSBiUhioiNQ/kJ1/Q1ngsZRen0TbWg0cMgv/kglpyiAv4CqXV1yiHGGP5c1BzGNluCpGXRyssQMfhooROWQQHEiKhj@I7f1hP22c3bzsaNA@WeNJNxqsSoABqfAe7GTUcUlSe5l9vgj0glgQkwaLLBFv7Y@jdRlHgd/xEycGbK17ALfyF5znxMQEs502VXeXAUXWohSRYnvWoi9gPoKKiDZaJKRNai2Nb@p8CmEEJYjGFWyTaCOwKLchlDwNULIs6UcVRvgwAuzgsRmAa48Hjxm2NsY1SYvx6JeISYyrYOnjACEskrOOHNZKKtWj56Gzxe/pQKGeAnOxItgKDImhnUMIR9cvdua8Zxu9eAlAomRHSIEVwNqiA9GwVsoB5U2BKRVBbJA4AnXLIy5Frh45rAmfEmhiZYmY0jKF0aVJTje2ud1rIvJPIJdS3jD5L1fluthETbWR0JQ1IDc4cpbReqFAJTFGWbHJ6VZJ0nT3T5ADIeEzqsl6pW4Rh/A1LOQeBN2WtUpMIZs6u9qkWWV8kHoD/rXdU@SAuIMxP3VDI@DX9GyS2HPUbmeYEwYWTFfw0epPZKrP2BPw1n5VI@g50neJ51RG6FOYFXamIwCx@k96Kc2WvKckbY8NNSdWzgbMbU7VsHgrdIdqK6ArX1uqaKeGDMCGH5eMT7/pUY/5u4X3hw09B@buS5ZI/a8kBziy70097XZd9N58WDGeok3WYnuytB2sL7eQkk/rxg6TrVJe0UD2pIa4UoGwj07k8LR1Kojqwar6PLZLYfvCFmnwtRGv4fRtpOBThClC0KljasHgJVj@qMkIsBT4HuN3mc/AgHBkAQn0gSOHQgFVwr9lTl2y8HC86hACXOCeV9FhpBVV9AVVlcmj3RZJOACLTbpVY0cZuulLVLZpdWtLKbAW6cT5Uc9jdwOd52I3lgflwILz@cVWn2TkE2TP@GQEyTPA0MuHOKSE0ct7aPH3WCH36yrSwAGaSv0uaXF5KoHIkeB/FiS5s5MOHsVzN4W0SnL4oF6QuFz7W2oKRUdVOjSaTINmqympRpGjRPPMCYrHjQ/pYtJfUIr8dFFxHdbzSdJdFbIWROTjDcTkSD1THV41jZXrLIHL5BSivf23jaJpALbRE5D75DRmwqU0GriD0J6WT4oRh4RM5kcIFd63/GvRpIzlqUd6m8EyGkpbq2b5ombAq8KM@zfQKLZWJVIRECgkOaWySeMU3JYOizYH0xzJzI3i4IPh5VAv2NVR5uS1gBegDoLmUIuySSDSY2KJFSHDtqb7YcKHO8zMENK0bRrbrrSuSpDayzmdaO2olUMW6u3bQ7w6X6JeZax2HWscm9ehWg4jsmhqcdsnM9GGVilWQRyywCc4heKEg5xGU6J2pExGcT6Wt/MT09XRy9Cstm1DmOdVOF5VyhkC4b2U2Eh0YRysNHlFDLktR4ROSPw7F4QNFRnt/QmwlM0rXQccr1pDC25V8ob37Klz1cbUVqSwJzwUkOXNtDwn8CKud2UHKXdXJed@ewdYHaHwqSa@jAf6AaY2e/5jX9xsRCL@R7SB/JPqlh4FCkifsw3Ig9O85oyBD3zR5pBJ8rE/HoWFSIH@CUuO8@jXcK58zfEZ8Fz4rLOYqYI8nV5RRD@ZFZM6YGlNMdzUAxcI@a3eTCsId4A5Xwd@ikU2Lcvs8chkPnFqtzetTg5blwQV30n2IOFmJXzTfnM7TxMq4g@VfYvm/UaxgxI3bDOoR7YqzlTw3dkhoEM@Tnnl@pcOI5ySZqV@guK2Bi/HUE3ewiuKwzHsFqUfw51El0gBz@Ap9HtyJXBbocIKecNyl4o5sAwLko3AccgH@2yO31PRwdBXxXsfEZ1sEB@B6wuXUthX5lNWOPLwYIqKu2aAkzvoXErPZOLNILGJeJD5YufqyI8z8AqCRS5POYfOcRwM1B1tQcGVv7dil7PTe8WIazvhJIgkpfTb2YEWUI7Zo0LhcBkjXUVoVlMgqg5BScUK7aNn2FFY1HWgizDEvb7JSFdshkAK2nAQm6P1xU86NOihyTh/Rte0AXvbivJE@zPn45GaViSWbXNy1MKEWufl06eB0maRAldKzjevcTxRU6VDp4ZoU8oMefFCTUHkG1Bv@3aqpdDkEHrKpMkmik4RiD/ZbX6JvkiVsh2JhMqAEAqFsnAFJRitkw3Hs9ygk7iydqJOv/JZMnbYiFkk6SGhAEoSIyN0xd/6qaFqL8RtgfpwARUkbKMrVcAsJYqaMACiuwmBGGQ5Ag@No/biaz4BaE/h0k7boWYmp5KFFglU9bFmnp6BD/CrnqcexOU8Ep8H1YpGrMkMGQsu8LIeX3EjElPEmZ05krhFNj3blIMD2ZmppVLEHcGu@NLefk9onWJ0pNWjZvczaFXvysCM0pcfh0LTiK7THtLR@pbGbDnsU40BVx30Xlti1wNkPsuK2pwNWUQAQOAOpk88CA@2qs743pM/3E35nCQX7txeECGcPdookJnnm2xFfeRiaknjE@GrhGBK3SEPMkkHWcp3PElp/JNhsb1681qZIKir2nvUzLxppbpsW5WSZ@PDmy6dAN42hoqRc1nHakYgPncQn1x75KPUAOn1/oYpEqbhQAIUXUrIwu0yi8xH3Nt9caOECx@qD1aKzFLwNvEgWWwSVFUEgKk76NdppddMdL9dDbjANZENXzWz7rAQNwLHVrG1KKx49wt9PDcl/CX6s8NyawYxOHgrJgsJzPxWosABiT96pOaYvSZNwJ4RdOahS6AqTyZyzcnPEFJ5XpYfSNHHac1WWTgRhfGfwALmfiVL2FQNJJ@4rUO7aZ44nZL1QGxcTYDI3G/edByWU66tLMAxTMy5uUIrhk8L3GqGyFTfXIe7YCNKKqFCoLfPRs43BCEnTOlWgSg5jw2UJIwnqxWS8OrhtsTXPpbyRIWYbgscJ8aORqqaIxXM/HaYs3TavVkBIKPd6RHJuUraSshE8U9tbImIqJUwGiLTAXnkBQxGCvja9OUOAe@nKUaLAMoW1MgP2z0PZZiedYfAyBJwrYs1q07Qo5nmYUudKGfDVrt@1GnTvHAbh7g1hXHaSCYXvQ91ihyTuWtuGy/HKTVs4ngb@7hI0JjrghscOh0V3srO1HTeuzQFjBQQu9mpMtslTIa@ZOPYNUXqmqZtzU6JiTAj4mx3OfSAsgMnvLRZtHVKXe4hLAq2w2KHZ1F8XekJ6e9Wi3UT6zJQIJ2ysp3/ZbMCKg6g7Jopl42Ts4qxv2JKBvBpOQXVdGeomgbSLSL1IcUal0foU40nD3JEFHmZFga6nQgJ7URcUx8h@MJyuIHUoH/iGAZy90UgqM4@qC10HyuSnIoXSH8ctf@A3PZGI3YviuDch36qOtWzG@GIioqdOi7G4D8bkkHuHwBbf28VHIfcZMeg1q0ZQY8mp/q0m00JWajDfbdQhvtpJ@MQQzADB/LD1pHfPmP7euqctFit0x0gJRDeASkels@b2Wy1D7xlSgUiGV8XsSDyX3en8Led9fBjeah23RG9syQKE9XwqkHgd@Wb6gaNEnJUNmmC6zQ3s1qyVNlFXAAyH/7OYdJc6bSt9cX5lgxaUrkkvUVQnhntQ/D3slRJijevPJ7IxtZJE0lJccXWrlQ51VFp/VYyrjLrdQi/d/RwhUoTDyLm9NNSNaI2ypFVsb6qN6SAsAaltGHKQrSOQ0NZu1I/d5erOO4Cot33oWDMsISu2mCx5/iu0Th5WR@OyJ@WM5AaN@FEqkCTphMbHIFYdaTTpfT7cYcCsqo40b55oXMr4zd@I0H5ncNPfoSeqefJ0pyAeGsQZrrVkvUhR8cqvtlfgkKDV9sB1HAWbmnt3eLqCgwdl5XKVYqldACdtX1WL3fMpYCo@iKNtxjY7BgChrqHAsEVtukajFABxXUyh1nVWsF/1awZAmEegV4y9ROOvuQNLRthqkSubvGrbhNu0@c81p0APkP3e6VzNvfOrEn3nmUJtyOENXq1En7XHWk6@tNMTjVgkGBMudmFo4gFuGV0EeKcRJwsktrAmETU/6OA2zKYNMLTyHVXu8xdp2KjZ2WANKkwtNd9PNsSu2eASX7idBkOujPLIu2n61x6GcY2yY9UJFpDyZZ7adb3iNqUy2jTbozJ2ylxVOpSwtspKLBg8lcSrJZiiq2epTR3VSlFmfSrnTuGIfBLyfqgY5f0Nz3DUtLcBsDnTndruloMfYxC4sraVXNc8e6WuuFep0LidhlCHWBkf9UVAqfPlFjKaLQjGx8gtkWFr3mDwBti47IUWA1bS7MDNSiSGyM4pczevdntEA@LPKYYCyb10@jBKPecTDhhCMTCR9mUACrchdUQ26W2rpqmsqIoCnNxyShsMCXfmt36WH/7mYChMNgd7MS@ih/JDvV1MkP1s8VV246W7MqbqZxmTmVOx5afdauTXeO2MrhReLYzhfLBOCX19EHyi0jf1dWm8TUP2ctwowM0oLC5PkFKd0NKvUSJZ11ZQDbCMvyUeVokZwqbik1pP6NGNzKzk7CyCNGy4ijVhnO7nlqcfhDD5iu@pBe2k57ZFDhK7ENq7ApY5ZdVI@8W0bKquziWgi5cR/GuyOa85PJwEryzD1nDHQ@G@rDIlYhZmjM@1/boR1eQFjPZelBh3JNy/KJStORG9sPWVZCu8yQQMBPh6U5Sd3fh2Z9WTJp3BwvT2QHAPz7IcCxDvJSMNohuZUanrSqsCkzFdVVCYtgfuIykWvS2FipM90MFBC@yR3Yk1e54qULapXE3cJ@adtzkLApixybOASSJ7sTCNDnLgWp3OL88vCtxjp4hVHJqFddrZrgESWExCLn1CLuY8gfRmgyI4DFV6kpWa7LHNBXh89uaCrKyx5yZqX09TGaF4bqfWxw2p7irynUnmD@6fhVoLIFvk@dzm@NqvVtFLhxh6e4ssUp/91JT/Krsus49FOOrSKM04vonSUGcuAqlOEbY20oob9ihlBQTLLRA@Ch2jrP4CKXTTWVnzj7IvRC1yrSd8k7HyMqc28GXZIkmoEvHh4Mlpxsu9EifYe/920dtJeMsh4x0CK474T1r1Ez5gF9EZLH2AULAkFqeOVoVFWAq3wrCViUncalKxyWJqVzDE98aqChuo4ciC7dGFORnBZqz@x7l9ETWw9PD4fS33lfckZexAZmRamyo3GPifDAzfJh11FYzXCPK4arfMBW2Bc24y20YWyZg1/Jwvwe3zOWnGwi2DtkF5dBZSZ14jcwno9anPNJ@iE4ulEWSrfUbFbq0FkECRpDpnz2@@@TAoiM1dy2HVR@MbEa2X/BwSnk@QUiryHZ7dEiaYoEPl9pQV1e7HDvfbIWrFslDjiNzO0tXaIbs14VaeYUbFOZTGA0FdzrUdzHH7Q@O212XzncsrttcACGZeR@/OYLf3EV3Z9bJL1m85KkyyJLVTO/6rd2773Ndw85O5LRwQjP5rWeCoN7sFN4n436/QeK3KrIIUx0jZAItNdruDpjx3Uqe4TThNB1nSoy2Ew@wdaXB3sueNouMNcsspUVatyfojm3JFTiA2xbbedvNrr8p5O7CcmBxSnaHV0QpkS@cfMuc7NVVR1eTMZrhzbGZs073fPOk5aalK//ZoIXXuezsaNGBmxsHQzDJ4MlvpaytCpvhnGvDmyLpbmL5ruoWfugbdEdKu0nLzOqqbHeL3e8tETD8foTSg3ncNRkIoPKL48AUflp/U55UOxduJbRIeUrOUD21cp/Hzk7hTnXUWYX7X05m0je6dnzc6rmZ@rou5zJMiYLsRKopPe6kp0MDZ2kq59GpHRe616hc1DO@ouKpAWV@6JwqvHrmuxRdzXi5g9jDlJbFxicFW4D8nQ2s7WqReygqd/jGLTSKA148LWWI@9ImWO4@bHZjfflxTCpGgB7uX8@fbx/RrPglhEjgxZV11X/qQ9a6LentZ80QQnldUnL3co4IaX71Yvwwbb@YxMPmyqIHrUvpqVuEsBgxIGxqTACV7B6urZpevgmtt89mT1SA6yx3hAHvlr3emoXx7H0719hWk0zKBO8iSRS63axV3DM@XPGzPGU3wr1cxxhQsJ7BUQZ7xQmogz14IDXUGZWpmq1uBXvNu/N9srXy9Zq32aoqJjmRKwFZy6BbgArtT/YUXavgHRG/bJ22G8mpZyeSGwDmL5UASyQJYluF5Rxj0C1o09oppJNoyJX7FtPtLIASsHYJxZZ2fH3sfKarcbCSkiVTuvzpboQiH6GtHu9sPzVASnmytR8XkaTOgWyqhG2XyG02qUn55hQ9BQjmV@G8ivB1zZFo3TbWltj7bTVvh45DbpshujIfEdy/vX0rFH9LUO2sIRTHY6pqXdZ8fbC7YxYepVHoQdmupYQ2T7dFHfQmlqv7AzvfzXC/QS3MVJbe4OKIDW52US/uQ@7vls5U@CJs@pbpZxnPBtx2jrf6NSG/9TfdjiGUacnJRAUvuIsQr6JN1s6QL2GMNKy@Mdsi2VgCa/3K2FJNIAl7FCS95ygcZq3YBuCpPPf0ku41@Pbx0zSNbE26/@@0FCjlb/LVGod3KkjKFFnfDnetft3xm0vtfKnvhAKXr6xwdn9U0nAQRrWygfkpK371ovZMvkeKl310FoWxALWajKcqLnPQMfn8QvfWyNl@B8KhJl3IGbYcmdtfq3BzD8vlNdHeoYh42fKlHILXmWb6OMBSBqfGv62n@a5PS19scQXDuSm@/WgEyaFIke@wbRH8ulBsPnBroelkMqZZ1aH9RsTO9zYFATlwar/fheK/TphMs8dXy/umfO75YcolmebB/wc "Python 3 – Try It Online")
### Program B
```
x, a = map(int, input().split())
while (x % 4398046511104) // 1024 != a:
x //= 4398046511104
print(x % 1024)
```
[Try it online!](https://tio.run/##VZvJrm3HcUTn/IrrgQESEKRqsjoD/BgODIiARD3YNER9PbVWHE4sUu/de5raVdlERkYWv/3r17/@45f5@@@//enrp68fv/7@07fvf/7l1z99/fzLt//79fsf/vy/3/72M3//8N0///rz3/776/vfvv7zq@a7rfbqvbf64esvf/nqbdTXf/z49dN/fff19Ruv/Pj/P/Tdt/9h1XzZj/7w@@9z9zHrvV19ncY/47ax92611uErnZ9qjNqTBe6Ye/TRV/HbO2O19dp@r1hlnTHWnovfzzuNt9vr7dzTb7V2WPLMs@@e7bU3356D5@21ec4dvH7eHPes3u7ZvVc/PPOszWrrrMt39n3Fu6NWtXNe8eOa1cZ4s7V9@nErdTrPuY2F@BRna332O8ee@87H2fzsavO@x1ucfHO49tjE22N1dsS@sMVbi61sbHfu5GWsw@P44L61Zp@cnQ@wwYdJDkvduotVap5eHOfW0ZL9YrXBuXh93jkfq422xsNaFwN7ghrt8qjBShzqsMy82INt@ci3MVOVNuUrHAZzaIbLgyafWBvDDB6/7uXMbGr0WZfVL07gL07N91gZU62hcdZmV@dw1j5YVVfgttuaO7m337cai1xefNqu18aYd7L4Io54l@OzRyzOWdlcYUVcO9j0LI7M1969A9sNDTZvPX3d2Px7DXtNtsAzc15MOA8/Eh8csrHIYTWOibWewcefeLjuG8WmGvY5Z2qw8R4Bd9kj5@yjBmGzyg/vc3ojNomKfi8mLILEc@vn5it4i3h7GORNLElYmA9XV2AdQ44IaKNhA46DS9g3e8OtuzaW2uTDmryNfd7Zaw3DmqhbZxJqm8eebmxgN@zn76PY9sghWJynd2K/DQJ2VedMhMYrPH@N9KG1BmfAnyyOezYn5og3e9qHZFg6oZFdxAAxMWpOD8j2yDc2pLExACHGTrAsefOuKNCTR36RPe4@SY4y1XjIIzB4zaWMUhZt2AuHLnzDKtvEAwNYchKhdftqgIEOBik4/Ov75S@NyFH4DgbEnwN/EZOghaYnigY@xNTEnWfveIZoIPtxBcFMsM8yg4hi4o50NcZ0J5iEEUmmtQebn2QtJqrkPF8DZAg6cIfAwxV8uwz1Ry4RS12zxsZkHyHKsUk5nNcnR3Wr9QAmHTMJ@Jp8eesCIo78uiLRGaf8l6RcmnUYKfM0wAR4S3jzCFO93sdtgA74gEmBFrJ/823N/okhYqMRN2CJ8Iq/sB/ZDeLMRxJgZBbHOGTEArwIuo0ryHXcS64QpCAtj2L/eOfyI69h4GkSDcELIxTbfBgT1wryWPcJGWwaG7If8NtwJzm2SCgqN3OBVagHV0jhLA/ofxwLrC7Rgf/pWPKR1MWSYgipgp2oG4AASNZ56sSGa4weIKMQLPOVkNFewDnBxXZx28E2pR/cEpmNxw67YhWCgXJAAmPHcwtQJfPrYQlWYz/AENkvXvUiBkjjYBOxdzicQMCL4PID/vCw6EfMYWy@iclINiBuaDJL2MG0w0JDlSDSGlv10PgddxZxTp4SrM@wTXRgYbxD3BB8hxwmN3lIWXF24XH268efha1ZOTvhNi1r3YA0MZ9FghoAACfsQCieha9qpcIuI5QlhSH25ztLnKYaWWuAZatl6hkpiq@IITZOlIl7@mEIYkANmOAZKRcatTAMhvDkvkZsaklAYuJRAUAAwc0lilGfSb9bwgR7JrZBT9LUzLP0utA0PThdkZeCAG5jpyS9ETSIA4ITp7H3Pg6rb4s0CGb54@hgEQnG028euzDoZk9dSkK9ZPOE/dVFGIpIIMC3PgZQ5A8Xp5sy3ccNAc18Bu2o38A/j@Bf8Mz0SymkllGCSY@dWsm/Z1icwG3Ox5rEFzvjPFOrHdFyQlnIYMD54l5rXqPQARh8WqZzMEAzMiy0QIqlEjuThiANiEfwE8nUshReHEdi8YyeTBf9iHtxELgwxIg9kAOqQ05xQECf9JWllHThkHPAAeyFgMF3eNEdyl3msKawWzbI1nG45XpoohW0JA27gGDYyfaGROOa9xP7Ab/4EHtgNK3Op6BlOhFGyfbZ4tIompEUoUJgnZKacELMyWmIeVjV@GQfhVr3X9mQNVc0tEIl4AEkigUIRhhNzwICDrkQHIXD4j7hp0mELLoWC30jLSPdrR5QDDbFDvCn5dCtlqUId4hIkAHAqQwT4ORuDv54gWAU5giVQ6EFyjC1KEQGU@ZDGrCyWHFn0JvYBB5FFUICjsOySyPweLJjg64anCwHKo1O9tAJoK4xKTU4BH7pOeCOuJ66GsKJkSkkHB/riF5EN2F1fDYeljJwcuEXXCUmgWpJjLWK9@G00kt@rGMJezJqbCBNpLqwCtF0LDZhOEQMdlq8Db/2zHyMXFti4WJnELpm4ACWN/zwmd@UHJIZRJ5ikwVDHjNa7MVqZVYSgISRtYz/Y2hqJEFCbvAtP8MWNBNZsM3UsprLW9nGThqzxJWvXdGTUiSN4dFsFtgxW6QA8iSKd6WE2yNcn1pS@G7tMNaPdBBIb/JVEAvnia6Hik2KYrm3cgxJtp0DYXfldc9CssUXA8YugvpDEcU0fkSzY4Vt1Wcvy8IbOA9jBguIcRwzm13QDu8k9suugfzrM8yCbBQZeWsYv2Cma@IYQYjAlzdSeYb4CEpuufbF3iY4iEPphInzCyGJvykyWIp62ABWjIFlIZqWOtJI2HvyQ0Grp9@4li8IEnHF9uR@lL/3wlKAauOCP1INrH7CADyUuGWDSUeJadklPplgk2zg7JTSt9ITxSuPwJS2kfdW2GNtauITriUnwUyYGhYmOGgYhpVInk8W28MQKATAlalKJDHdsb7dz1nSDLnsseBbJXy2Cc0fcFJ/7/JPnk2Y0@aQdvwzDXjQjyQjayho4rXu2GEuwxqw43rbA9sXKGXZ1FIT4tkls6POiQkzfI@UZWH545MhEFEeANsRC/IcawNJnozB3oQsDJHqLL3hZVmgrRDutcvjQwKM7fC17fjDU@aSPa5tA8WHZLVHsmJa4PhuP1YGFsIzxyjatjNNHOZrAA6wSHqJ@KIe6AlB7KFQILTQooHYHF@C2HGo5y7NB05HEE0jWluSvgZD2UY9w@mZ8bjMKqoViCSxnjA906NjsC3XW34ZRCAorqAjDOlzY8HOnLeb3l72C8QEsGW3PPShDNeWFR8oJZQbYqcSB6rSTV3gK9RZLbMFBBbk08cmyLLjM4EoxQObLwoth7M/ITP0jx4xEFjsKnE84553uwLK0wPLDnFJfgTTYytGLRZdcZqsW9wADvnpSn5BmKs1Qb1rlECbJSYJ1bhjf5SFJU@f2swSwWoEjK2IZNEmRxw59hvUNzHpKYUQHl3Xj2zUJk/UbTLPKQUQRWRjpCIYVuJs0MY2knaZh1CB@QDkIYRp2aNuQ73ZHXBeTgukuCkQxTDn43IUWARhSGpjzKnHuqVBZBeoqbyginzehgILNpnMEbZIWvITp3V1G3lfWjpxGhABs1aAnnIsoGl6w1G2yZlIacKWcNEUU3KfskyIEXza0qzjKeTTDs3EOhRh08HeTQXoSl9xChEnpDfZrae3wSY4SaNmY6ggwde0D6Y7dtbHprYk8DcUEZjHwva5fhqoxqPGsdbvBrIsw/phc6FWcVPQ@F06RNJfRQkebzsnVzs9zKlCOeUSbr5Mkm3fPM17NmX/0MwQOT/hTiWEjhGLHwGp2cenO5bimHnD8vHsfCVRn6hIF8/ygrSMEwgl8x@HGWI1y/CX6pkN0rKDXQIV7YpNahebWVGuAvujidUxsOVrt4ZfeaQVnJjq@aDnMigUZPTlR9TgpHbfW65LkE0FF4UH1QfyT7gyLsU@bCVrNlABL/iPTzmSd5veFp4sjKgSSTjtEC3SfLinuuEKoZaGjIwDLWhH7YxeBBPVI9jmjQDUjFkwA7ML9PgS0KNMkbZP8j4tHAYE1buCwWSoiS5GNdWbKTmQrEUX7VYZnDy0gySfZZMAsjKMqXgGe6RDsemUc8IO4K1lVTe2ZmjnNHKppyXvuNKnFw2I87CjlvwCDwhkKMCUAJGf8DqpS1QDzhQmK08g2prdjuceSm@pBE0JUClRQYOSA1cgMeUUzW0I6R956dkAEssyRWxZ0QmNq6lu063/em@qGol8CmYAv8WPc125zpP7YZSKmAb9VQwEmqIVA2REaPBFS2/FIxsvPdntAfCU7S@ZexWtRWIbNjYTo9iuUYNs77ouWNKhMq6HbV9Ftnhqvt12gUAcdpsEmoKvIp3HMuxJB8L1jngXWnBmWjfi1U4gqAZYY20OaggSc11tTPEMfk4KkPTgAbE9lDGJWaARR6hcnqNKg1FVKVWqrpqVGWJqlF8EedI480bkIPVZkrYro1B7RtrhqYKrki5Gdj1FcIj00w4pkdEUZzmm1iKqycWh3E6D0UPnBSuyjJ7CFopgF16PcrTAZn9IAMXv5QMxM4TLrqOifDSBVC6lYK@MYifDuW4UC44I6NkBWJyG2mlwDjB9aaWmtqDeTOlvRG0xIstMVdAuxSDuhhCdKkOfTcYKchp2KYYRKoKqBd6vAFzDFtGOyrZJGrpbNMEjY@L3ZbHCKfYFT/7qt8x6JfelufkEFtTKTX1aVcWCnukEgaWaaTNpHMnXJM9DQQUMeuoaOnpKdogxNfKp7XmzoriBgDYuPaXwpqqT/jvqTOrqdvDgYY/KtnkC046anFGLowlCjvjGslYQOZjsF@frp6W4SeYX4SFlKmUqIGCrcLEjNQJoiRFiq2Da4RS6AWlxqWxG4CKXMp5o6rVHisDZwg4DLqUkjnmvUgvlsN1AvNKCjaQaaqtAnXzYMjXFew41nV6ABH/ggWKubdNUU6Br2h73I@ESErIXuNBJF23cGmY43DZ52b@XAh3m3c46pDw4k9dIWI6qCEY9swqJXxLeZuEg6j7Y32xOt@bVivYPblR1DwIqyAK8Q4Vrp7OHVV7TTfkHu/CRUFiiT95jRykEWCXACsBHjUHOHVNCasgXCtBVlbGSATScx@5HFSlBgfOvFHiqF7Uo@bo5/pjKfjbbw@MTrTfSXBRqj37UWxyKmD0gBJ8ksob9ZpOZm0KhO87l1GoNP86uOqBkoprfVallO5ZDc@pGbYZL8xMueh9ZBc8o6EfH71auE7UjiTcd6AyViAd5bMaYR5tGMbHInyQbESfHIe2VsLrifRMqtAUVwXbYqiwkO6kiSIWStSPkyWc0iFxFBTvheT7yCNYxtSRr2/GVkqyzRrHH2QFNkYxXokKjR1hRD4b8R1wGTpe@cdLFYZbaqFAjRXN2OVVSZeLWKRWs5u8WjmGgXrHoqJOSYJzZHskUHjLLJVvKtOPa9DZ7DScxT70Ky6pykVnKuinurHhDEEqhwgqlqr@VupVQmsPQGQlsCBZqbg78mlMCDSSlFWzSIYpwUsAh2X09CiaMYrvPxICamjLeVUaCXHL87uzE9LFqchAh3IaAL4QIK@RJcMzGxIGc2aLhxHVLfCAaw897qpc@HEp6rP4SZxt5m@8tr7fBVBYXFI6a7fr0qVZhO5xpaXXo4ZTJKalK6JVmKjqxqKm6oiQpdvK3y7EnJ2dgjgBikPj9a/UFdh1AyuVW2gobLqdzjviawpX1V/b@wnZZxemEg7eV8Spg7ARLLr8iOxDzAZPuzMKNWkfUmJ52MqWavH1U@jjHcERzyG5mZqKH9JzDXptM8EJd6zhX/nQBXf1TKTCzRAuvyiwxAsSryMnsbN1UaLfPkKo15QuBZljdKXxKeaYdqSin7LZfUgJl0Z45YcmvDfCM267aKbijsEz8H9sQB3kz28/hnZ0QNirWujCzZT3KhnJl4H26qy4GPbvqDzvSq85mLMPGUFpTp4zLAba4qrSbIdJQFHFWNxOEz3mJcwjtyKJECSi3/OZIuLN1Wgg1ypN7BvZfGR6wQF@hJ6oM7kK2s7wIIeRZ15zZppTZ4xFJN3g/0vgDXMoOx25uGqQOedR3r8ktPC@rMxsBHa7zafguSfQJoGfplmFhwJRcrEucgPrHxOaBkW6UmEEU@xYVO@WoqYSQqxYONFQ2QuyXCZuOs1usgDBjValEFdFBgLK2gXBaNEvta1vDhx1zOr9WOFVtJ2O2UenVBEfYWwAQXFRbpXsV9zT7WjtNxVSZWHp0BaISh5QDwHoQFMPfD@/NwPelGfTlqbjQQ5sw/kj3vvS@asc@yge4Uo1Gt3WHeBwE50iQjx/f0pDAM7llXtsqPimeipTqvT5ylnvSrione/Wj5@36jAlVMZyYlXyEFM3cVtR0RpuBI8Dm@LMUaskwI5jfBf4nAZVcOL7ZDnJUf7eDcyU3KaVjVE6@7MKV7LtDgBNi@jKVmCrGzhpFLvFzBGhh8TY5kgLLNTF7bAPZY1nNZS5ODajV6o@mMqsfFaRph6TGKd2rkWmlFNKMc7jmRREJtD2Z4xcFN7vC4Y0SJyjNzthMktHJLByvlldInv0P5e7IKVuURKdnS/6PB3NlYbmeFbMMhQoEkmLEOfvdco2RGyV7ZHRUyvHK9xk@pwn10Gw7E1f5o/r//sgtBKRhI544W@exSn0n94R063SEQlxaTyvTHEf5jqasNV5NkK4oL5/PVI18lIh4p8U7GE@iZt/cnTJL2JQP5SgvqTTtDaYtkxMfB37gItu5AYfP3ZFm@BuouYdgY@C1Ke8cZCbMaUj4XCKQbhzvtzi4HWkvj2q@TYHcnfPhIABHdLpBW@8cKTgMIcMAnNIop4IORowxiSHFazoXy@HHzWRRlcGbG5wTSqS63XqqYEml1QtsyoXNA97K1ewinI1bwUxxe3hnQ8pVkhDB0qkNdnScRuhYHETiLptRRKYcSNZzKWE46blOeVQm5IHbof@JkCyZjDocNvmUw510K0NRANTcol21lyGXSobhuAwK5/JqDBnEtnSejn9s5aSv3ks4JzLqVkuw/vgJP2zTfx1MiQZefbLC25x6C8q5g1eQho2FpWRZK31DvZzUkTBqly1tlk2pBLQUqymlYAM2Rel8pZWOz23ulJSaxnXAHaGRFOXR21k89Wd4AeY6UtDrcoxumApaO4JSroCp@1Uui/XozcYcoSPJda6tzCCr6HKo6J1HKLCbsrGBVU79AMh6JWBn@O5IUAnUXMXeyQvNGgnpqDx8Lv4E4qV7kuTLr86ZcY8itkARgHNCcbw/8D7tfIbKqisKS7LyFgnYQQLcMjOh5kzdUVp5mUk@90xE218jiMyxVKlmWtcdROkUpbTRMpi5IY4sEO35pI/ZJ1eqrkKrkCeVdkZh09ZmxneinJETxUsdzyHn065yKbFIPqGypvbkQN8ZuYXdEaJikeVrpDZaiWxD7CjVNSwF3XSaYade/Rkmd3oUb9QYZzYJamN4bPraB8qV/pqbbIpC93P5S4y273gZhjX9sK014Syk5FVwkG6bbZJY72kpxNgEy7wc@UZgcGaxnYl4ZeopQzpB0u1LEXAICE89xqHCVI4cmZMLsFJCEE5Bo1UGtcs8prRKPI49bVc/92KZdWV5QQInSjRVbqxM/Ol3HZefMF4@nF7JNV1i7MxCVaajBXrbA3TpUZYIGm8VOClpdtoVXust02Ho2UV5w6LC8uzwnI0S@MqVxrs3hYg4GYfCBADQvTaz0zSIWuqzypO@YVEmJI1iaatXhdTz1KyUQbxCujWJwsFHyXHz04sY27nTdiyyZAaqbk4brllHxFmCvGvrY1SeeraofuxoJMWwFGmdHpk5tLdWL/X25S0Hv90Vq@zLvUkqXbfDoGBl1KlkFh3hOkQlKJWinfvbwHevnbFnRzbN/sKE62pXz8Gl97C8CCNV@OhhSnCGMcZcI9feXuYTjg/359bKhwhg1SmnGWpb0asdJYofTuW8bCGvkv18lJfcPqDkgYPNobBpJ4h85iomhYN5Gks5r5dEpEruLlPWroossfMwzmBtEp3AO12DyWXQryI2og44mvbuqVqoonuzzm6xQ2nmZlYvkRDawskT1F02r3wYFdNbrl4GcrjmVQTJq9MYuJZTTY94Tyhx@DFgobjqth1BjVyfAdwkGce7PBIedQDpDXGzEsdeOvLGqpliuJt3beYC1vR26FZrwDQrUpadd/psYsl7jo6RvPCBSYYCnex5Ox6MxOAfsaZzS8k4G1TK@@PuyDCKvFMlJHuXwO5cNmiB7ivTfzZJ7HsD1LS0Una7HgFANVuK5hDlebsvRaHr6Kb05H0Yo6dy18Ra7/207mA0E/DIhwpq@tYGwQvJ81O7HaDOoD55XsvuwamJ0qbX4NR530fwqRZBJJdAdZ7386zqMq9r7@vlIm/FEGpeF5ledc9kOteZ3NCRw6hrTPl3ZUJKoXsqjVEWrJqRg9kqOUXgOGxzZYX2HRkuvYiTAk3pUtEVxTd4iJr2ytK7Z2ylAKuGNIPO1mBBz@s19k1N5Xl7l1iI5SnHjO9eXbA/K6vSzpWml1vWbQXvl2O/EgDCzLb6VLpex2mZxWiUlvShqbJ/ECjV1Vp0Km@2Hy@setvFG1zY3XWjiDk18@6OolfuCup8b6Xu6IOJSUWSnmvgZpaXEU/3QqYfonqWY1bv6l9vDuVuBNk8bTmk3JUrIY46Q@nVs24G00KCiAUSOvbwmoEdwPPabvROG2tHO9ajXunxCGWVhLRNR3LsaNB7alM5nVTrTsBUIJb3TXvmbN05aS6dqrcfy17EHmn@zcBpeufHWzzvY6QKWqZndb4BzSsn0OLN8VJgZLyh5nvsaLoV2OhSrlT5cesxuH2BprA0vtz/HbkNomYYGp9rqGq2XR7rRRtbU8f1n24A4G2Z1Kw0RZFe/a8eFFatLF6JjGoxpMoSE6e/SdXKJFqK5/SeGuL1abuj3GMR@1aYx5E7@h8IEI5pU5RQmpO99Dkq2i8zo@d9S7LK3tnrv9Mm6Ckw8a8QPL5mrtxzsPNv "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/171132/edit).
Closed 5 years ago.
[Improve this question](/posts/171132/edit)
New to code golf and enjoying it. I have a problem that I cannot figure out and am curious if others can solve it.
Start with two dictionaries, `y` and `z`:
```
y = {'a': 1, 'c': 3, 'e': 5, 'g': 7}
z = {'b': 2, 'd': 4, 'f': 6, 'h': 8}
```
`y` and `z` both map length-1 strings to numbers, where each number is between 1 and 26 (inclusive) and represents an English letter: a = 1, b = 2, c = 3, d = 4 , ... , z = 26.
The goal is as follows:
1. Double each number (i.e. value) in `y`, and replace the key with the letter corresponding to the new number.
2. Do the same for `z`, but triple each number instead.
3. Populate a dictionary `x` with the keys and values from both `y` and `z` in descending numerical order, for instance:
```
x = {'x': 24, 'n':18, 'm': 14, 'l':12, 'j': 10, 'f': 6, 'b':2}
```
Good luck!
Example:
Starting state:
```
y = {'a': 1, 'c': 3, 'e': 5, 'g': 7}
z = {'b': 2, 'd': 4, 'f': 6, 'h': 8}
```
After `y` operations:
```
y = {'b':2, 'f': 6, 'j': 10, 'm': 14}
```
After `z` operations:
```
z = {'f': 6, 'l': 12, 'n': 18, 'x': 24}
```
[Answer]
## Python, 174 155 113 86 70 68 66 bytes
It's actually my first time here and here's my attempt. Let me know if I am doing anything wrong.
```
lambda y,z:{chr(v*(3-v%2)+96):v*(3-v%2)for v in{**y,**z}.values()}
```
**EDIT**: After OP's edit and @Rod 's comment I noticed I have some mistakes. I also took out the sorting attempts because it simply can't work with Python dictionaries.
**EDIT2**: -16bytes thanks to @JonathanAllan
[Try it online!](https://tio.run/##PchLDsIgAIThq7AxPEQTi1Yl8SZu6APbpNIGKwklnB1n5er7Z5a4DrNTxT6eZTLvpjMkyk2ndvAsCKYOYVfx/b3m@r/s7Ekgo0tCRCnElo/BTN/@w3guix/dyixL1FBNTpLQFirYwwt8wWuWJNEGVeHp4BlaWMMB3jLn5Qc)
] |
[Question]
[
Jill lives in the (magnetic) north pole. One day, Jill decided to go for a walk, travelling in the four directions (north, east, west, south) for some lengths, with the help of a compass. Your task is to find whether Jill ended up where Jill lives, i.e. the magnetic north pole.
Only south is defined at the north pole. Walking north or south changes the latitude, while walking east or west changes the longitude. The longitude is not defined at the north pole. As a result, Jill would have ended up at the north pole if and only if the distances Jill walked to the south sum up to be equal to the sum of the distances Jill walked to the north, and the distance Jill walked east and west do not matter.
# Input
A list of pairs of (direction, amount). The input shall be valid. The amounts will be integers. Acceptable formats include:
* `"N200"`
* `"200N"`
* `200i` (complex number)
* `(0, 200)` (0123 for NESW)
* `(200,0)` (the above reversed)
# Output
Two consistent values, one for the case that Jill did end up in the magnetic north pole, and one for the case that Jill did not.
# Testcases
Truthy inputs:
```
S100, E50, N50, W50, N50
S10, E1000, S30, W400, S10, W10, N50
S30, N30
S10, E50, E50, N10
```
Falsey inputs:
```
S100
S10, E314, N5
S300, W135, S10, E35, N290
```
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer in bytes wins. Standard loopholes apply.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
SĊṆ
```
Input is in form of complex numbers, which will be real or purely imaginary.
[Try it online!](https://tio.run/nexus/jelly#@x98pOvhzrb/h9sfNa0BIvf//6OjuRQUonUNDQyydBS0TQ3ABJCpC2ICWbE6UHmQNFAVUFTXGKzABMwGSwBJiD6oarACbWM03VDDweZkxXIpxOog7EZRaGxoAlKJMA1ih7EpzD5tEFPbyBKsLzYWAA "Jelly – TIO Nexus")
### How it works
```
SĊṆ Main link. Argument: A (array of directions)
S Take the sum of A.
Ċ Get the imaginary part of the sum.
Ṇ Take the logical NOT of the imaginary part.
```
[Answer]
## JavaScript (ES6), 36 bytes
Takes input as an array of *[orientation, distance]* arrays, with *0123* = *NESW*. Returns a boolean.
```
a=>!a.reduce((p,[o,d])=>p+--o%2*d,0)
```
The result of the modulo in JS has the same sign as the dividend:
* ***(0 - 1) % 2 == -1*** (north)
* ***(2 - 1) % 2 == 1*** (south)
***.map()* alternative, 36 bytes**
```
a=>a.map(([o,d])=>a=~~a+--o%2*d)&&!a
```
### Test cases
```
let f =
a=>!a.reduce((p,[o,d])=>p+--o%2*d,0)
// truthy
console.log(f([[2,100], [1,50], [0,50], [3,50], [0,50]]))
console.log(f([[2,10], [1,1000], [2,30], [3,400], [2,10], [0,50]]))
console.log(f([[2,30], [0,30]]))
console.log(f([[2,10], [1,50], [1,50], [0,10]]))
// falsy
console.log(f([[2,100]]))
console.log(f([[2,10], [1,314], [0,5]]))
console.log(f([[2,300], [3,135], [2,10], [1,35], [0,290]]))
```
[Answer]
## Batch, 78 bytes
```
@set l=0
@for %%s in (%*)do @set t=%%s&call set/al+=%%t:i=*0%%
@cmd/cset/a!l
```
Takes input as command-line arguments in complex format (e.g. `-100 50i 50 -50i 50`). Outputs `1` if Jill arrives back at the pole, `0` if not.
[Answer]
# Pyth, 3 bytes
```
!es
```
Input as a list of complex numbers.
[Try it online!](https://pyth.herokuapp.com/?code=%21es&input=%5B-100j%2C%2050%2C%2050j%2C%20-50%2C%2050j%5D%0A%5B-10j%2C%201000%2C%20-30j%2C%20-400%2C%20-10j%2C%20-10%2C%2050j%5D%0A%5B-30j%2C%2030j%5D%0A%5B-10j%2C%2050%2C%2050%2C%2010j%5D&test_suite=1&test_suite_input=%5B-100j%2C%2050%2C%2050j%2C%20-50%2C%2050j%5D%0A%5B-10j%2C%201000%2C%20-30j%2C%20-400%2C%20-10j%2C%20-10%2C%2050j%5D%0A%5B-30j%2C%2030j%5D%0A%5B-10j%2C%2050%2C%2050%2C%2010j%5D&debug=1&input_size=4)
```
!es
s # Sum
e # Imaginary part
! # Not
```
[Answer]
# Mathematica, 10 bytes
```
1>Im@Tr@#&
```
Pure function taking a list of complex numbers (same format, and implementation, as [Dennis's Jelly answer](https://codegolf.stackexchange.com/a/119051/56178)). `1>` saves a byte over `0==`, and is valid thanks to the facts that distances will always be integers and you can't go north from the north pole.
[Answer]
# Java 7, 135 bytes
```
boolean c(String[]a){int n=0,s=0,c,i;for(String x:a){c=x.charAt(0);i=new Short(x.substring(1));n+=c==78?i:0;s+=c==83?i:0;}return n==s;}
```
Those restricted input-format are pretty annoying, but I guess that was the main part of the challenge..
**Explanation:**
```
boolean c(String[]a){ // Method with String-array parameter and boolean return-type
int n=0, // North-sum
s=0, // South-sum
c,i; // Two temp integers to save bytes
for(String x:a){ // Loop over the input-array
c=x.charAt(0); // Set `c` to the first character
i=new Short(x.substring(1)); // Set `i` to the actual number
n+=c==78?i:0; // If `c` == 'N': increase the North-sum with `i`
s+=c==83?i:0; // If `c` == 'S': increase the South-sum with `i`
} // End of loop
return n==s; // Return if the North- and South-sums are equal
} // End of method
```
**Test code:**
[Try it here.](https://tio.run/nexus/java-openjdk#nZAxa8MwEIX3/IrDk0yNseuYphEidMhYLx4ylA6y4iYCRwqS3LoY/XZXSKZpx3gQp8c73n13rKNaw@u4AtCGGs5gaqTsWiqAodooLk5v7zQeuTAgSJZo91jC8YdUsw3D1vmMDCk7U/ViUBZjTkT7BfVZKoOGVPeN9q0oj2MsHggj5Gmz49sMay82hRdWtaZXws0hGtsJ4No3nSOawT4lP8KFcvHLBW6wAweov7VpL6nsTXp1lukEYsgjzJ0jRHWeZVEC0b70pQrlcFNgHd09cT7NpfpPXYS89SyDfciXxoe4qljKVf5bNl8Qs3Ryka/DzvevPN@sKP@ccB9U9fh8A7IrO/0A)
```
class M{
static boolean c(String[]a){int n=0,s=0,c,i;for(String x:a){c=x.charAt(0);i=new Short(x.substring(1));n+=c==78?i:0;s+=c==83?i:0;}return n==s;}
public static void main(String[] a){
System.out.println(c(new String[]{ "S100", "E50", "N50", "W50", "N50" }));
System.out.println(c(new String[]{ "S10", "E1000", "S30", "W400", "S10", "W10", "N50" }));
System.out.println(c(new String[]{ "S30", "N30" }));
System.out.println(c(new String[]{ "S10", "E50", "E50", "N10" }));
System.out.println(c(new String[]{ "S100" }));
System.out.println(c(new String[]{ "S10", "E314", "N5" }));
System.out.println(c(new String[]{ "S300", "W135", "S10", "E35", "N290" }));
}
}
```
**Output:**
```
true
true
true
true
false
false
false
```
[Answer]
**Microsoft Sql Server, 94 bytes**
```
select sign(sum(iif(m like'[NS]%',stuff(m,1,1,iif(m like'S%','-','')),0)))+1 from a group by g
```
[Check it.](http://rextester.com/ZXD32021)
[Answer]
# Python, 23 bytes
```
lambda s:sum(s).imag==0
```
Input as a list of complex numbers.
] |
[Question]
[
You know that some decimal numbers can't be expressed as IEEE 754 floating points. You also know that arithmetic with floating points can give results that seem to be wrong:
* `System.out.print(4.0-3.1);` ([source](https://stackoverflow.com/q/4895154/562769))
* `0.2 + 0.04 = 0.24000000000000002` ([source](https://stackoverflow.com/q/327544/562769))
While one wrong number with an error that is this small might not be significant, more of those error might be.
## Task
Find a system of linear equations in form of a matrix A \in R^{n \times n} and b \in R^n, such that the result vector is as wrong as possible. Reference is the script below, executed with Python 2.7.
## Points
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def pprint(A):
n = len(A)
for i in range(0, n):
line = ""
for j in range(0, n+1):
line += str(A[i][j]) + "\t"
if j == n-1:
line += "| "
print(line)
print("")
def gauss(A):
n = len(A)
for i in range(0,n):
# Search for maximum in this column
maxEl = abs(A[i][i])
maxRow = i
for k in range(i+1,n):
if abs(A[k][i]) > maxEl:
maxEl = A[k][i]
maxRow = k
# Swap maximum row with current row (column by column)
for k in range(i,n+1):
tmp = A[maxRow][k]
A[maxRow][k] = A[i][k]
A[i][k] = tmp
# Make all rows below this one 0 in current column
for k in range(i+1,n):
c = -A[k][i]/A[i][i]
for j in range(i,n+1):
if i==j:
A[k][j] = 0
else:
A[k][j] += c * A[i][j]
# Solve equation Ax=b for an upper triangular matrix A
x=[0 for i in range(n)]
for i in range(n-1,-1,-1):
x[i] = A[i][n]/A[i][i]
for k in range(i-1,-1,-1):
A[k][n] -= A[k][i] * x[i]
return x;
if __name__ == "__main__":
from fractions import Fraction
datatype = float # Fraction
n = input()
A = [[0 for j in range(n+1)] for i in range(n)]
# Read input data
for i in range(0,n):
line = map(datatype, raw_input().split(" "))
for j, el in enumerate(line):
A[i][j] = el
raw_input()
line = raw_input().split(" ")
lastLine = map(datatype, line)
for i in range(0,n):
A[i][n] = lastLine[i]
# Print input
pprint(A)
# Calculate solution
x = gauss(A)
# Print result
line = "Result:\t"
for i in range(0,n):
line += str(x[i]) + "\t"
print(line)
```
Let `x` be the correct answer and `x'` the answer that the script above gives.
Your points are `(||x-x'||^2)/n`, where `|| . ||` is the euclidean distance.
Your solution gets 0 points if it gives `nan` as result.
## Example
bad.in:
```
2
1 4
2 3.1
1 1
```
The first line is `n`, the next n lines describe the matrix A and the last line describes b.
```
$ python gauss.py < bad.in
1.0 4.0 | 1.0
2.0 3.1 | 1.0
Result: 0.183673469388 0.204081632653
```
The answer should be:
```
Result: 9/49 10/49
```
So the score would be:
```
((0.183673469388-9/49)^2+(0.204081632653-10/49)^2)/2
= 3.186172428154... × 10^-26
```
The last step was calculated with [Wolfram|Alpha](http://www.wolframalpha.com/input/?i=%28%280.183673469388-9/49%29%5E2%2b%280.204081632653-10/49%29%5E2%29/2).
[Answer]
Taking this as a question about numerical inaccuracy in calculations rather than in conversion from numbers which can't be exactly represented in 64 bits to 64-bit representations, we're interested in nearly singular matrices.
Let's take the simplest possible case:
```
[a b] [x] = [p]
[c d] [y] [q]
```
has solution
```
[x] = [(dp - bq) / (ad - bc)]
[y] [(aq - cp) / (ad - bc)]
```
so that if `ad - bc` is very small we find that errors in `dp - bq` and `aq - cp` are magnified.
We also find that scaling `p` and `q` scales the absolute error linearly, which points out a massive flaw in the scoring system of this question.
How can we get a nearly singular matrix? In order of ill-conditionedness:
1. `a=1+e, b=c=d=1` gives `ad - bc = e`. This allows us to get a determinant of 1 ulp (which for IEEE 64-bit is on the order of 10^-16).
2. `a=1+e, d=1-e, b=c=1` gives `ad - bc = -e^2`. This allows us to get a determinant on the order of 10^-32.
```
2
1.000000000000001 1
1 0.999999999999999
1 1
```
gives output:
```
1.0 1.0 | 1.0
1.0 1.0 | 1.0
Result: -9.0 10.0
```
rather than `x = 100000000000000, y = -100000000000000`
Similarly,
```
2
1.000000000000001 1
1 0.999999999999999
1E307 1E307
```
gives
```
1.0 1.0 | 1e+307
1.0 1.0 | 1e+307
Result: -9.1120238836e+307 1.01120238836e+308
```
rather than `x = 1E321, y = -1E321`. This seems to roundly beat Johannes' solution (it gives a score on the order of 10^642 vs 10^588), and moreover it would continue to generate about the same score even if the input numbers were tweaked to be exactly representable in IEEE 64-bit, whereas his would then score 0.
3. `a=d=e, bc=0` gives `ad - bc = e^2` but this time we can choose `e` to be a very small number rather than 1 ULP. In principle this allows us to get a determinant on the order of 10^-600 (i.e. underflowing IEEE 64-bit). However, so far I haven't managed to get a decent score without an infinity in the answer, and I gather from your chat with Johannes that even though the question doesn't rule out infinite scores, in practice you do.
[Answer]
Ok, this feels kind of cheating.
# Tcl, score 1234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234567901234569876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876543209876544
```
gets stdin a
puts $a
for {set i 0} {$i<$a} {incr i} {
set r {}
for {set j 0} {$j<$a} {incr j} {
lappend r [expr {$i==$j?1:0}]
}
puts $r
}
puts ""
puts [join [lrepeat $a [string repeat 8 308]]]
```
] |
[Question]
[
Your task is to print this exact text:
```
| | | | | |
&***********&
| Code Golf |
| e---------f |
| d___________l |
| o-------------o |
| C_______________G |
###Dennis$Dennis###
#####################
```
# Rules
* Trailing or leading newline is allowed
* [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code wins!
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 71 bytes
```
\|6*Ṅ`&`×6*+∞`¬꘍ »₆`:⌈Rvf÷4ɾd7+‛-_f4Ẏ*$++J‛ |Ḃ∇++÷`###%$`∞‛ṫ¹%\#21*WøĊ⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJcXHw2KuG5hGAmYMOXNior4oieYMKs6piNIMK74oKGYDrijIhSdmbDtzTJvmQ3K+KAmy1fZjThuo4qJCsrSuKAmyB84biC4oiHKyvDt2AjIyMlJGDiiJ7igJvhuavCuSVcXCMyMSpXw7jEiuKBiyIsIiIsIiJd)
```
=== Top bit ===
\|6*Ṅ`&`×6*+∞
\|6* # Six |
Ṅ # Join by spaces
`&` + # Append to an &
×6* # six asterisks
∞ # Palindromise that
=========== Code Golf bit ===========
`¬꘍ »₆`: # Compressed string `Code Golf`, two copies
⌈R # Split on spaces and reverse each word
vf÷ # Make each a char list and push each
4ɾ # 1...4
d7+ # Double + 7 -> 9, 11, 13, 15
‛-_f4Ẏ # Extend `-_` into length 4 and turn into char list
* # Repeat characters by numbers
$++ # Join the `Code Golf` bit by those
J # Append `Code Golf`
‛ |Ḃ # Push ` |` and `| `
∇++ # Prepend `| ` and append ` |` to each
÷ # Push each value to the stack.
=== Final bit ===
`###%$` # Literal string `###%$`
∞ # Palindromised
‛ṫ¹% # Format (replace % by) "Dennis"
\#21* # 21 #
WøĊ⁋ # Output the stack, centred and joined on newlines.
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 69 bytes
```
× |³⸿×*⁶&⸿Ｅ⁵⁺ק_-ι⁺⁵ι |Ｅ²×#⁺χι‖Ｏ←Ｍ±⁶±²…Dennis$¹³↗↖Golf←floG edo↙CedoC
```
[Try it online!](https://tio.run/##VY9LC8IwEITv/ooQRRKp4AM91JNUEMEXojdBSt3aQExKG6uC/z1ua9B6y858M5uNkjCLdCit3WZCGbYXV8gZJS/qkSHnk8ZHpseMfgfHdBAZ15B2nVmFKRt5ZCtvueOnZqHO8GD01MWg4M4clW8cypWc/@UHHnGrmtTR/V6Fl9wOYgmR2RSQSYT9JcQG5ZUugK3hEhpgY@x1z8GvOnhGEoJEp4zOQCmRt7C9Xx1bhf1DuhOXxHwDKJTl@Me5lvHvRt@psdRzAmddc2b6rpwboBOgZa3tFvIN "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Outputs the right half of the cake body, reflects it, then adds in the lettering.
```
× |³⸿
```
Handle the candles.
```
×*⁶&⸿
```
Handle the icing.
```
Ｅ⁵⁺ק_-ι⁺⁵ι |
```
Draw the bulk of the cake.
```
Ｅ²×#⁺χι
```
Draw the base of the cake.
```
‖Ｏ←
```
Reflect to complete the cake body.
```
Ｍ±⁶±²…Dennis$¹³↗
```
Cyclically extend the string `Dennis$` to 13 characters and output it in the appropriate position.
```
↖Golf←floG edo↙CedoC
```
Add the two copies of `Code` and `Golf`.
[Answer]
# JavaScript (ES6), 145 bytes
```
_=>` 5|@@@@@
4&*11&
4| Code Golf@
3| e-9f@
@ d_11l@
@ o-13o@
| C_15G@
#3Dennis$Dennis#3
#21`.replace(/@|.(\d+)/g,([c],n)=>c.repeat(n)||' |')
```
[Try it online!](https://tio.run/##JYpNCoMwGET3OcUHFk1af4ipiy6UQAseoi0aYhRLSESlq9w9jXQ2b5g3H/EVm1znZc@MHZQfa9/VTQ@V40cQXOMzpXGgg3s4QGv1GGbmQGW3o3EYOko1RxxsRpnlKDw7WrXBReyhjJm30x8RQ1FJ@3xVixZS4YK7HL@GCymmFD/lOzWkbuShldixIc4l4BLipTWb1SrXdsIjJsT/AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 114 bytes
```
6$*¦¶ &11$**&¶ ¦ Code Golf¦¶ ¦ e9$*-f¦¶ ¦ d11$*_l¦¶¦ o13$*-o¦¶| C15$*_G¦¶ ###D$D###¶21$*#
¦
|
D
Dennis
```
[Try it online!](https://tio.run/##K0otycxL/P@fSwEIzFS0Di07tA3EVDM0VNHSUgNzDi1TcM5PSVVwz89Jg8gDRVItVbR0IVwgLwWkPD4HxAXy8g2NgZL5IF6NgrOhKVDKHaxSWVnZRcUFSB7aZgTUoMx1aBmXQg2XC5dLal5eZvH//wA "Retina 0.8.2 – Try It Online") Explanation:
```
6$*¦¶ &11$**&¶ ¦ Code Golf¦¶ ¦ e9$*-f¦¶ ¦ d11$*_l¦¶¦ o13$*-o¦¶| C15$*_G¦¶ ###D$D###¶21$*#
```
Insert most of the cake using run-length encoding.
```
¦
|
D
Dennis
```
Make a couple of substitutions that save a few bytes. (In particular, the `¦` substitution allows me to write `6$*¦` to mean `| | | | | |`.)
[Answer]
# [Perl 5](https://www.perl.org/) + `-p0513`, 119 bytes
Pretty much just RLE, nothing too exciting.
```
s''4 6P
4 &11*&
3 P Code GolfP
P e9-fP
P d11_lP
P o13-oP
| C15_GP
3#Dennis$Dennis3#
21#';s/\d+(.)/$1x$&/ge;s/P/ |/g
```
[Try it online!](https://tio.run/##JYnNCgIhFEb3PsWFEe0Hs5tjEC0nmO19gGA22jAgKtmixTx7ZrT6zjlf9s9gay1S9nAm1oNA3AlmgGBIzsOYwoMYNPUX9SMChzgFYgQJjUrEVhjQTmP7THfzMS6F/8d07ISdvBZ9d/vNYas5vrnQs2@FNKx6rvWT8mtJsVSVjxbNFw "Perl 5 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 77 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
„| 11∍'*11×'&.ø”|ƒËŠˆ |”©Âá4.£v'|y„-_NèN·9+×y®á2ä`‡««‚Ć}”¼´$”13∍…###.ø¬21×».c
```
[Try it online.](https://tio.run/##yy9OTMpM/f//UcO8GgVDw0cdvepahoaHp6ur6R3e8ahhbs2xSYe7jy443aZQA@QdWnm46fBCE71Di8vUayqBenTj/Q6v8Du03VL78PTKQ@sOLzQ6vCThUcPCQ6sPrX7UMOtIWy1I155DW1SAtKEx0PhHDcuUlZWBhh9aYwS059BuveT//wE)
**Explanation:**
```
„| # Push string "| "
11∍ # Extend it to size 11: "| | | | | |"
'* '# Push character "*"
11× # Repeat it 11 times: "***********"
'&.ø '# Surround it with leading/trailing "&": "&***********&"
”|ƒËŠˆ |” # Push dictionary string "| Code Golf |"
© # Store it in variable `®` (without popping)
 # Bifurcate it (short for Duplicate & Reverse copy):
# "| floG edoC |"
á # Only leave the letters: "floGedoC"
4.£ # Only leave the last 4 characters: "edoC"
v # Foreach `y` over these characters:
'| '# Push character "|"
y # Push character `y`
„-_ # Push string "-|"
Nè # Index (0-based modular) the map-index into this string
N· # Push double the map-index
9+ # Add 9
× # Repeat the character that many times
y # Push the character again
® # Push "| Code Golf |" from variable `®`
á # Only leave its letters: "CodeGolf"
2ä # Split it into two equal-sized parts: ["Code","Gold"]
` # Pop and push both separated to the stack
‡ # Transliterate
«« # Append the top three strings together
‚ # Pair it with the "|"
Ć # Enclose; append its own head (the "|")
} # Close the foreach
”¼´$” # Push dictionary string "Dennis$"
13∍ # Extend it to size 13: "Dennis$Dennis"
…###.ø # Surround it with leading/trailing "###":
# "###Dennis$Dennis###"
¬ # Push the first character (without popping): "#"
21× # Repeat it 21 times: "###################"
» # Join each list on the stack by spaces,
# and then all strings on the stack by newlines
.c # Centralize it, adding leading spaces where necessary
# (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `”|ƒËŠˆ |”` is `"| Code Golf |"` and `”¼´$”` is `"Dennis$"`.
] |
[Question]
[
**This question already has answers here**:
[Full Width Text](/questions/75979/full-width-text)
(146 answers)
Closed 7 years ago.
Basically, between every character of a uni-line string, add a space, but there can't be two spaces in between one character.
* `aesthetic` becomes `a e s t h e t i c`.
* `The quick brown fox jumps over the lazy dog` becomes `T h e q u i c k b r o w n f o x j u m p s o v e r t h e l a z y d o g`.
* `I'm Nobody! Who are you?` becomes `I ' m n o b o d y ! W h o a r e y o u ?`
This is code golf, so the shortest answer in bytes wins.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
ḟ⁶K
```
`ḟ`ilter out spaces (`⁶`) then join by space (`K`).
[Try it online!](https://tio.run/nexus/jelly#@/9wx/xHjdu8////H5KRqlBYmpmcrZBUlF@ep5CWX6GQVZpbUKyQX5ZapFAClM5JrKpUSMlPBwA "Jelly – TIO Nexus")
[Answer]
# Python, 36 bytes
```
lambda s:" ".join(s.replace(" ",""))
```
[Answer]
# Retina, 8
```
.
$0
```
Whitespace is significant - there are single spaces at the end of the first and last lines.
[Try it online](https://tio.run/nexus/retina#Dcq9DkAwFAbQ/T7FJ5HYxBuYLSaJufRSv5dS1MuXM58AopTiDCEoPk7D59BSZRi7G9oJjZV7RScPRrdsB@Rii39hVq@Hlp6KZEEpjWgfoTYCZRleXP4B).
[Answer]
# Pyth, 4 bytes
```
jdsc
```
Splitting on whitespace and then joining seems shorter than removing the spaces.
In pseudocode:
```
' ' d,Q = " ",input() # preinitialized variables
'jd ' d.join(
' s ' sum(
' cQ' Q.split() ))
```
[Try it online!](http://pyth.herokuapp.com/?code=jdsc&test_suite=1&test_suite_input=%22aesthetic%22%0A%22The+quick+brown+fox+jumps+over+the+lazy+dog%22%0A%22I%27m+Nobody%21+Who+are+you%3F%22&debug=0)
[Answer]
## Haskell, 22 bytes
```
(((:" ")=<<)=<<).words
```
Laikoni saved 2 bytes with a nice use of `words`. Previous answer:
```
(=<<)(:" ").filter(>' ')
```
[Try it online](https://tio.run/nexus/haskell#@59mq2FrY6OpYaWkoKSpl5aZU5JapGGnrqCu@T83MTNPwVahoLQkuKRIQUUhTUEpUQEIkhSSlf4DAA)
[Answer]
# [V](https://github.com/DJMcMayhem/V), 7 bytes
```
Íó*/
X
```
[Try it online!](https://tio.run/nexus/v#@3@49/BmLX0Froj//zNSc3LyFcrzi3JSAA "V – TIO Nexus")
Just a straightforward regex, and an "X" to delete one leading space.
[Answer]
# tcl, 28
```
puts [split [join $s ""] ""]
```
testable on <http://rextester.com/VFP77495>
] |
[Question]
[
**Closed.** This question is [off-topic](/help/closed-questions). It is not currently accepting answers.
---
Questions without an **objective primary winning criterion** are off-topic, as they make it impossible to indisputably decide which entry should win.
Closed 8 years ago.
[Improve this question](/posts/52819/edit)
A friend of mine challenged me to write a function that works with both of these scenarios
```
add(1,2) // 3
add(1)(2) // 3
```
My instinct was the write an add() function that returns itself but I'm not sure I'm heading in the right direction. This failed.
```
function add(num1, num2){
if (num1 && num2){
return num1 + num2;
} else {
return this;
}
}
alert(add(1)(2));
```
So I started reading up on functions that return other functions or return themselves.
<http://davidwalsh.name/javascript-functions>
<https://stackoverflow.com/questions/17235259/javascript-self-calling-function-returns-a-closure-what-is-it-for>
<https://stackoverflow.com/questions/17235259/javascript-self-calling-function-returns-a-closure-what-is-it-for>
I am going to keep trying, but if someone out there has a slick solution, I'd love to see it!
[Answer]
# JavaScript (as asked)
This is a "correct" way to do it but hardly the golfiest way. It's unclear if you're asking for shortest code (the question looks like it will be closed soon anyway.)
```
function add(a, b) {
if(typeof b === "undefined")
return function(c) { return a + c }
return a + b
}
```
[Answer]
# JavaScript ES6, 23 bytes
```
add=(a,b)=>b==+b?a+b:c=>a+c
```
If you are willing to use ES6, you can use fat-arrow functions and conditionals to write the function.
# JavaScript, 55 bytes
```
function add(a,b){return b==+b?a+b:function(c){return a+c}}
```
Here's the same function in regular (current version of) JavaScript.
`b?` will check if b is a non-falsey value
`a+b` if it is, return the sum of a and b
`:c=>a+c` if it's not, return a function with a single argument c which returns the sum of c and a
] |
[Question]
[
**This question already has answers here**:
[We're no strangers to code golf, you know the rules, and so do I](/questions/6043/were-no-strangers-to-code-golf-you-know-the-rules-and-so-do-i)
(73 answers)
Closed 9 years ago.
This is one of my favourite poems I wanted to share. Especially because it looks good for compressing. Who cares about literature in the 21st century anyway.
# Goal
Your goal is to write the **shortest program** possible that prints out the following poem:
<http://pastebin.com/aXV0C515>
# Rules
* The HQ9Monkey++ language is **prohibited**
[Answer]
# Python 2.x (Baseline answer, ~~651~~ 650, +/- 40% gain)
```
print'eJxNU0G2pDAI3OcUXA2VmLxJwE+S73NOP2DHHncIBRSVsiFvonCSKDWown/oKpYLQRJEq0RUifFd0XzQ/F6UcANhWFAWXFqwOvREcGYLWtdRG8joE94HUwtRpc6Ew+R8hqG2ED5xIhXjo7kR+MyY99RD5gmNmcp2Fz7f7WegUnglkLGLZtsfEv4+fA/smbg3WPXKvDtVa5s796zlIYrD91VsnfSRBcuRcKEe6Dc/QDhk8NYg5WbDFE8OkajDl+lhJ5g+l7XNNTWXAgZnQi0XVNwoWM6ulUfmipcwox0fTCE2pgYc7DEu5Zt80K61pRocevfMRX8cIl8iYo0JFXkf1O5HWlXO7T/VLl76PoCpxrBKdbBAs+BbsgPcGj2JPY/dL+xLccWfQbCb7KUgrCnXA/kvUTBriBGRe3lHBsI1wUImb3AHffT7TGc6W0uuIfbgLMmuM2Xuln7m4k4ApcObTYmenicfx0EKlaoRMJt576diBkxJhnE1Py6udHJfzLYTt83w5lbU7qdW1DWZy31PH8pQKM6o2Ziy2RbU2l4Pmq33gnj32EWx0NrplvamPU2LK70J74Ph5ejWX5QbnKJl/kt3dBL4gH/NMmPU'.decode('base64').decode('zip')
```
[Answer]
# Bash, 499 bytes
Why wasn't this a standard loophole?
```
0000000: 7461 696c 202d 6334 3733 2022 2430 227c tail -c473 "$0"|
0000010: 7a63 6174 3b65 7869 740a 1f8b 0800 5d28 zcat;exit.....](
0000020: a753 0003 4d53 5176 8430 08fc cf29 b81a .S..MSQv.0...)..
0000030: 2a9a bc26 6049 529f 3d7d 27ae 6ef7 2fc2 *..&`IR.=}'.n./.
0000040: 00c3 3056 d6c5 9c0e 3197 4ac5 f44b ce8c ..0V....1.J..K..
0000050: 5808 1669 4566 65b7 75fd cc78 dae5 fe9e X..iEfe.u..x....
0000060: 5c78 2153 9ad8 269e 6a40 9e5a 143a 121e \x!S..&[[email protected]](/cdn-cgi/l/email-protection).:..
0000070: b579 2f95 acb7 1bde ba4a 0dab 5bb9 0303 .y/......J..[...
0000080: 66c7 d38c bd06 0aaf 8f28 6e20 e4a9 0a8d f........(n ....
0000090: a66b da62 0b49 6fec 9a24 2f57 e2f5 5dbf .k.b.Io..$/W..].
00000a0: 3bbb 848f 002b 37f3 0402 21f2 cf43 78e7 ;....+7...!..Cx.
00000b0: 9644 5ba5 d9cf a4db e08a b267 e896 3c3f .D[........g..<?
00000c0: 54b9 8f81 856b 137f 84e1 bc47 9ea4 05f9 T....k.....G....
00000d0: 490f 9076 ebba 548a a9a2 9bf3 a161 1569 I..v..T......a.i
00000e0: f4a6 ba63 0728 74a2 ec99 5352 ce04 bc0a ...c.(t...SR....
00000f0: 7b3e a9f0 2201 31ec 6b8f d285 4f53 65ac {>..".1.k...OSe.
0000100: 1f20 9282 2b80 5dc7 9ba7 fc0e 3ee8 2137 . ..+.].....>.!7
0000110: 4295 76bf 6a9e 495f 0363 6f2a 86ca c8ce B.v.j.I_.co*....
0000120: ba75 a9d7 a166 b763 f927 db6c a4de 3780 .u...f.c.'.l..7.
0000130: 704a b395 0136 aa78 bc53 d860 d8a3 45c3 pJ...6.x.S.`..E.
0000140: 85a0 80a9 04c8 35f3 7717 daa0 7cce 4c73 ......5.w...|.Ls
0000150: 4c65 67fd 1509 b087 8188 5dc3 1b2b 09cf Leg.......]..+..
0000160: 9126 81c0 61b8 e8a5 e0ab bbca 516b 1c2a .&..a.......Qk.*
0000170: 720b 83a5 603d 4873 95b4 23e5 6106 72d9 r...`=Hs..#.a.r.
0000180: 4731 a468 f1b9 7adf 7771 2a52 4000 561b G1.h..z.wq*[[email protected]](/cdn-cgi/l/email-protection).
0000190: b5af 0c4c 18a3 7570 8527 a721 751c d6b8 ...L..up.'.!u...
00001a0: cb0e 5e16 e0e1 58f6 3656 2dec 7384 d3c7 ..^...X.6V-.s...
00001b0: 9cd6 5d29 cb7a bf2a dae4 0553 d8d1 e0ff ..]).z.*...S....
00001c0: a209 b527 ad57 0d36 5ab3 cc4d 2e69 2fda ...'.W.6Z..M.i/.
00001d0: b76f 7996 4fc2 5b57 fa30 756d 1f94 2b1d .oy.O.[W.0um..+.
00001e0: e6f9 fe9f aed7 2174 35f8 03f5 2b98 87b5 ......!t5...+...
00001f0: 0300 00 ...
```
base64:
```
dGFpbCAtYzQ3MyAiJDAifHpjYXQ7ZXhpdAofiwgAXSinUwADTVNRdoQwCPzPKbgaKpq8JmBJUp89
fSeubvcvwgDDMFbWxZwOMZdKxfRLzoxYCBZpRWZlt3X9zHja5f6eXHghU5rYJp5qQJ5aFDoSHrV5
L5WstxveukoNq1u5AwNmx9OMvQYKr48obiDkqQqNpmvaYgtJb+yaJC9X4vVdvzu7hI8AKzfzBAIh
8s9DeOeWRFul2c+k2+CKsmfoljw/VLmPgYVrE3+E4bxHnqQF+UkPkHbrulSKqaKb86FhFWn0prpj
Byh0ouyZU1LOBLwKez6p8CIBMexrj9KFT1NlrB8gkoIrgF3Hm6f8Dj7oITdClXa/ap5JXwNjbyqG
ysjOunWp16Fmt2P5J9tspN43gHBKs5UBNqp4vFPYYNijRcOFoICpBMg183cX2qB8zkxzTGVn/RUJ
sIeBiF3DGysJz5EmgcBhuOil4Ku7ylFrHCpyC4OlYD1Ic5W0I+VhBnLZRzGkaPG5et93cSpSQABW
G7WvDEwYo3VwhSenIXUc1rjLDl4W4OFY9jZWLexzhNPHnNZdKct6vyra5AVT2NHg/6IJtSetVw02
WrPMTS5pL9q3b3mWT8JbV/owdW0flCsd5vn+n67XIXQ1+AP1K5iHtQMAAA==
```
] |
[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 9 years ago.
[Improve this question](/posts/26523/edit)
Your goal is to write an obfuscated program that displays the current time.
Guidelines: The program can print local or global time. You are allowed to draw ASCII numbers, display an analog clock, etc. No input should be needed. Whether you include 12 or 24 hour, including AM/PM, milliseconds and seconds or not, it all doesn't matter. This is a popularity contest.
Inspired by [sykes2.c](https://stackoverflow.com/questions/15393441/obfuscated-c-code-contest-2006-please-explain-sykes2-c), an impressive display of confusing naming, obscure language features, and clever tricks.
[Answer]
# Analog clock, JS
Analog clock? Challenge accepted.
Golfed/Obfuscated into the zone of not-exactly-understanding-what-it-does-even-after-reading-through-a-few-times:
```
for(var a=new Date,b=a.getMinutes(),c=a.getHours()+b/60,d=[],e=Math.round,f=Math.PI,g=Math.sin,h=Math.cos,k=0;11>k;k++)d[k]=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(var l=0;l<f;l+=0.05){var m=e(17/11*5*h(2*l)),n=e(5*g(2*l));d[n+5][m+8]=1}for(var p=0;2.5>=p;p+=0.5){var q=e(17/11*p*h(-(c*f/6)+f/2)),r=e(p*g(-(c*f/6)+f/2));d[r+5][q+8]=2}for(p=0;4.5>=p;p+=0.5){var s=e(17/11*p*h(-(b*f/30)+f/2)),t=e(p*g(-(b*f/30)+f/2));d[t+5][s+8]=3}d[5][8]=1;a="";for(k=d.length-1;-1<k;k--)a+=d[k].join("").replace(/0/g,".").replace(/1/g,"O").replace(/2/g,"h").replace(/3/g,"m")+"\n";console.log(a);
```
Outputs something like:
```
.....OOOOOOO......
...OO.......OO....
.OO...........O...
.O...h.........O..
O.....hh.......OO.
O......hOmmmmmmmO.
OO.............OO.
.O.............O..
.OO...........O...
...OO.......OO....
.....OOOOOOO......
```
...yeah, guess what time it is here. (Hint hint not AM)
Human readable version:
```
var date = new Date();
var min = date.getMinutes();
var hrs = date.getHours()+(b/60); // set up date
var a=[];
for(var i=0;i<11;i++)a[i]=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; // set up array
function putX(x,y,i){a[y+5][x+8]=i;} // just for source neatness; this is expanded out in the obfuscated version
for(var p=0;p<Math.PI;p+=0.05){ // draw clock border
putX(Math.round((17/11)*5*Math.cos(2*p)), Math.round(5*Math.sin(2*p)), 1);
}
for(var p=0;p<=2.5;p+=0.5){ // draw hour hand (transforming the angle to work)
putX(Math.round((17/11)*p*Math.cos(-(hrs*2*Math.PI/12)+(Math.PI/2))), Math.round(p*Math.sin(-(hrs*2*Math.PI/12)+(Math.PI/2))), 2);
}
for(var p=0;p<=4.5;p+=0.5){ // draw the minute hand like the hour hand
putX(Math.round((17/11)*p*Math.cos(-(min*2*Math.PI/60)+(Math.PI/2))), Math.round(p*Math.sin(-(min*2*Math.PI/60)+(Math.PI/2))), 3);
}
putX(0,0,1); // set the center point
date=""; // reuse date for maximum confusion :)
for(var i=a.length-1;i>-1;i--)date+=a[i].join("").replace(/0/g, ".").replace(/1/g, "O").replace(/2/g, "h").replace(/3/g, "m")+"\n"; // output ASCII art to string
console.log(date); // output string to console
```
[Answer]
# Python
Might as well.
```
exec(lambda s:s[::2]+s[1::2])('ipmepno r(t" hwtetbpb:r/o/wtsiemre;.wgeobvb/rHoTwMsLe5r/."o)')
```
[Answer]
## JavaScript / HTML (757 bytes)
Prints an analog clock on an HTML5 canvas. There's probably a lot more efficient ways to do this, but I think it turned out looking nice.
```
<canvas><script>S=150;c=document.currentScript.parentNode;c.width=c.height=2*S;t=c.getContext("2d");z=Math;r=2*z.PI;o=r/4;h=[[1,0.93],[4,0.9],[8,0.7]];m=[0,0,0];function d(){t.clearRect(0,0,c.width,c.height);t.lineWidth=2;t.beginPath();t.moveTo(2*S,S); t.arc(S,S,0.99*S,0,r);for (i=0;i<60;++i){a=r*(i/60)+o;x=0.99*S*z.cos(a); y=0.99*S*z.sin(a);t.moveTo(S+x,S+y);s=0.96;if (!(i%5)) s=0.90;t.lineTo(S+s*x,S+s*y);}t.stroke();u=new Date();m[0]=r*u.getSeconds()/60-o;m[1]=r*u.getMinutes()/60-o;m[2]=r*(u.getHours()%12)/12+(m[1]+o)/12-o;for(g=0;g<3;g++){t.beginPath();t.lineWidth=h[g][0];t.strokeStyle="black";if (!g) t.strokeStyle="red";x=h[g][1]*S*z.cos(m[g]); y=h[g][1]*S*z.sin(m[g]);t.moveTo(S+x,S+y);t.lineTo(S,S);t.stroke();}setTimeout(d,500);}d();</script>
```
Human readable version on JSFiddle [here](http://jsfiddle.net/MasterShizzle/Y9rk3/).
[Answer]
# GolfScript
The ultimate example of a magic number!
```
230140410535893441750932406053255553
23/`3/{~}%+'"#{'\+'}"'+~
```
Explanation coming soon.
[Answer]
# CJam
```
"et phone home"S/_,_@T=~><{_A<{R_,+\+}*':}/;
```
Prints the local time as HH:mm:ss (24-hour)
Spoilers:
>
> `S/` splits by space (S=" ")
>
> `_,_` gets the resulting array length (3) twice
>
> `@T=` extracts the "et" part (T=0)
>
> `~` evaluates `et`, which gives the current date and time in an array
>
> `><` extracts the time part (starting at index 3, length 3)
>
> `_A<` checks if a value is less than 10 (A=10)
>
> `R_,+` evaluates to "0" (R="")
>
> `\+` prepends "0" to the number
>
> `{...}*` executes the block if the condition (<10) was true
>
> `':` is the colon character
>
> `{...}/` executes the block for each array element (hour, min, sec)
>
> `;` pops the last value (a colon)
>
>
>
[Answer]
## SVG + JavaScript (272 937 bytes)
I'm sorry; couldn't help myself. The SVG is probably way too big to fit on StackExchange, so you can access a live demo here (please note, it could lag your browser; do it at your own risk): <http://varden.info/~mlindvall/jstime.obf.svg>
Viewing the source code might crash your browser; do it at your own risk. Otherwise, downloading it and opening it in Notepad++ should be safe.
Since there are no rules, I'll have to admit I got huge help from [an obfuscator](http://www.jsfuck.com/), so this is more like a proof of concept rather than a real submission. Still, it was kind of fun to see this work.
Human readable version:
```
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg height="44" width="110" version="1.1" xmlns="http://www.w3.org/2000/svg">
<text x="10" y="14" style="font-size: 14px;">Current time is:</text>
<text id="id" x="0" y="44" style="font-size: 30px;"></text>
<script type="text/javascript">
function t() {
var a = new Date(), timeArray=[a.getHours(), a.getMinutes(), a.getSeconds()], delimiter='', result='';
for (c = 0; c != 3; c++) {
while (('' + timeArray[c]).length != 2) {
timeArray[c] = '0' + timeArray[c];
}
result += delimiter + b[c];
delimiter = ':';
}
document.getElementById("id").textContent = result;
}
t();
setInterval("t()", 1000); // Run every second for an updating clock
</script>
</svg>
```
] |
[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 9 years ago.
[Improve this question](/posts/25747/edit)
My obsession with set theory continues. I believe that most programming languages have neither sets as possible structures nor set theory operations such as Union and Intersection. If I am wrong then this question becomes trivial and I learn something new.
It would be fun to ask for the code golf construction of a full set structure where a set could contain any possible structures within the language and operators such as is a member of, is a subset of, union and intersection etc. However that is much too broad. So I will simplify the puzzle.
**Terminology**
An Alphaset has only lower case letters as elements.
The structure for an Alphaset can be defined as you wish and the method used should be explained. It could be just a list of letters read from a file.
As an example I will use an array as a structure for an Alphaset.
An Alphaset can contain a letter once only and order does not matter.
['a','b','c'], ['b','c','a'] and ['c','a','b'] are equivalent Alphasets.
The operation Union forms an Alphaset from two Alphasets.
['a','b','c'] Union ['d','a', 'g', 'b'] is ['a', 'b', 'c', 'd', 'g'] or an equivalent.
A Big Alphaset has the same structure as an Alphaset but can contain repeated letters, eg ['a', 'b', 'a', 'c', 'b'] is a Big Alphaset.
If A and B are any combination of Alphasets and Big Alphasets then A Union B must return an Alphaset.
This gives a way of producing an Alphaset from a Big Alphaset should it ever be necessary for when A is a Big Alphaset the A Union A will be an Alphaset.
**Puzzle**
**Input**
A an Alphaset or Big Alphaset
B an Alphaset or Big Alphaset
**Ouput**
An Alphaset that is the Union of A and B.
**Test Data**
Testing should demonstrate that order of elements within the Alphaset does not matter.
ie the following should all produce equivalent results.
['a','b','c'] Union ['a', 'c', 'd']
['b','c','a'] Union ['c', 'd', 'a']
['c','b','a'] Union ['d', 'a', 'c']
Shortest code wins
[Answer]
## Python2 - 21 (or 15) (or 1)
Sets should be in the format `set([element1, element2, element3...])`
```
print input()|input()
```
If running from the interactive prompt is allowed, remove the `print`.
Note: If [the Mathematica answer](https://codegolf.stackexchange.com/a/25754/12205) qualifies as being 1 character, then in the Python interactive prompt this should also qualify as 1 character:
```
set(['a','b','d','z'])|set(['c','z','d','a','k','a'])
```
Sample input:
```
set(['a','b','d','z'])
set(['c','z','d','a','k','a'])
```
Sample output:
```
set(['a', 'c', 'b', 'd', 'k', 'z'])
```
[Answer]
# Mathematica, 1 Chars
It's a built-in feature:
[Answer]
# APL - 1 char
`∪` is the union operator, so `1 2 3∪3 4 5` returns `1 2 3 4 5`. In APL, there are no brackets around lists.
Other diadic (two-argument) set operators in APL are `∩` (intersection) and `~` (Without):
`1 2 3∩3 4 5` = `3`, `1 2 3 4 5~1 3` = `2 4 5`
Many languages have libraries built especially to deal with sets:
* Haskell - [Data.Set](http://hackage.haskell.org/package/containers-0.5.5.1/docs/Data-Set.html)
* Java - [java.util.Set](http://docs.oracle.com/javase/7/docs/api/java/util/Set.html) (an interface implemented by 8+ builtin classes)
* c++ - std::set
* Ecmascript 6 will have a [Set](http://people.mozilla.org/%7Ejorendorff/es6-draft.html#sec-set-objects) object
Almost every language has some sort of way to handle sets. Usually googling "somelanguage set" will point you towards the documentation for that language's set
[Answer]
# Bash + coreutils, 30
Not sure how strictly the input and output formats need to be followed, but this does a union correctly:
```
echo `tr \ "
"<<<$@|sort -u`
```
In action:
```
$ ./union.sh "a b c" "a c d"
a b c d
$ ./union.sh "b c a" "c d a"
a b c d
$ ./union.sh "c b a" "d a c"
a b c d
$
```
[Answer]
# Golfscript, 3 bytes
```
~|p
```
### Example
```
$ echo '["a" "c" "d" "b" "c"] ["f" "b" "e"]'| golfscript alpha.gs
["a" "c" "d" "b" "f" "e"]
```
### How it works
```
~ # Interpret the input string.
| # Setwise OR (union)
p # print
```
] |
[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/269789/edit).
Closed 11 days ago.
[Improve this question](/posts/269789/edit)
# Challenge
Given a positive integer \$N \ge 3\$, generate an alternating series of \$N\$ random numbers within the range \$[1, N]\$, such that their sum equals \$N\$. Expressed mathematically as
$$N = \sum\_{i=1}^{N} (-1)^{i-1} a\_i$$ where \$a\_i \in [1,N]\$ are random terms.
**Input**
\$N\$
**Output**
A string representing the alternating series of \$N\$ terms (each prefixed by \$+\$ or \$-\$) that sum up to \$N\$.
**Notes**
Random numbers can be generated using any standard random number generation function. For example, `rand()` in C, `random.randint()` in Python, `Math.random()` in Javascript, etc.,...
# Examples
| N | alternating series |
| --- | --- |
| 3 | +1-1+3 |
| 4 | +4-1+3-2 |
| 5 | +4-2+4-4+3 |
| 6 | +5-1+4-4+3-1 |
| 7 | +6-1+4-7+4-1+2 |
| 8 | +6-7+7-5+7-1+2-1 |
| 9 | +3-7+8-3+2-8+9-2+7 |
| 10 | +10-4+4-2+8-3+1-4+5-5 |
| 11 | +11-7+1-2+2-10+3-5+10-2+10 |
| ... | ... |
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṗḅ-⁼ɗƇ⁸XṚṭNƭ€”+
```
A full program that accepts a positive integer, \$n\$, and prints a possible alternating sum, in the given format, with \$n\$ terms with absolute values from \$[1,N]\$.
All possible outputs are equally likely.
**[Try it online!](https://tio.run/##AS0A0v9qZWxsef//4bmX4biFLeKBvMmXxofigbhY4bma4bmtTsat4oKs4oCdK////zY "Jelly – Try It Online")**
### How?
```
ṗḅ-⁼ɗƇ⁸XṚṭNƭ€”+ - Main Link: positive integer, n
ṗ - {[1..n]} Cartisian power {n}
-> all length n lists formed of values [1..n]
Ƈ - keep those for which:
ɗ ⁸ - last three links as a dyad - f(potential, n)
- - literal -1
ḅ - convert {potential} from base -1
-> last - penultimate + antepenultimate - ...
⁼ - equals {n}?
X - uniform choice
Ṛ - reverse
€ - for each:
ƭ - alternate between:
ṭ ”+ - a) tack to '+'; and
N - b) negate
- implicit, smashing print
```
[Answer]
# Google Sheets, 154 bytes
Assuming \$n\$ is in \$A1\$
```
=LET(F,LAMBDA(F,LET(o,JOIN(,MAKEARRAY(A1,1,LAMBDA(i,_,IF(MOD(i,2),"+","-")&RANDBETWEEN(1,A1)))),IF(A1=SORTN(QUERY(,"select "&MID(o,2,99))),o,F(F)))),F(F))
```
Recursive formula that generates a random sequence. If the sum is \$n\$, it returns it, otherwise it generates a new sequence and the process is repeated.
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 120 bytes
```
from random import*
def f(n):
while sum(L:=[s*randint(1,n)for s in(1,-1)*n][:n])-n:1
return''.join('%+d'%v for v in L)
```
[Try it online!](https://tio.run/##FYxBCsMgEEX3nmI2QSdtCpJNEXKD3CBkUUgkljrKaFJ6equrz4P3fvzlI9D4jFyK5eCBX7TVcT4Gzr3YdgtWERoB38N9dkinV7OZltQ301FW@k5oA0MCRxUGjT2ti6EVBzJaAO/5ZJLy8Q5VkN1tk90FrbhqATOWyO3HqhGx/AE "Python 3.8 (pre-release) – Try It Online")
Brute-force method. Generates a list of \$N\$ random numbers until their sum is equal to \$N\$.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 19 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
L¤ãε(2Å€Ä'+ì]ʒOQ}ΩJ
```
[Try it online](https://tio.run/##ASgA1/9vc2FiaWX//0zCpMOjzrUoMsOF4oKsw4QnK8OsXcqST1F9zqlK//81) or [verify all possible results for a given input](https://tio.run/##ASYA2f9vc2FiaWX//0zCpMOjzrUoMsOF4oKsw4QnK8OsXcqST1F9Sv//NQ).
`ε(2Å€Ä'+ì]` could alternatively be `ε'+ìι`(.ι}` for the same byte-count:
[Try it online](https://tio.run/##ASYA2f9vc2FiaWX//0zCpMOjzrUnK8OszrlgKC7OuX3Kkk9Rfc6pSv//NQ) or [verify all possible results for a given input](https://tio.run/##ASQA2/9vc2FiaWX//0zCpMOjzrUnK8OszrlgKC7OuX3Kkk9RfUr//zU).
**Explanation:**
```
L # Push a list in the range [1, (implicit) input]
¤ # Push its last item (without popping): the input
ã # Cartesian product to have all possible input-sized lists
ε # Map over each inner list:
( # Negate all values
2Å€ # Then for every 2nd item (0-based index is divisible by 2):
Ä # Absolute value to make the negative value positive again
'+ì '# Prepend a "+" instead
] # Close both the every and outer maps
ʒ # Filter:
O # Sum the values in the list together
Q # Check whether this is equal to the (implicit) input-integer
}Ω # After the filter: keep a random inner list
J # Join it together to a single string
# (which is output implicitly as result)
ε # Map over each inner list:
'+ì '# Prepend a "+" before each value
ι # Uninterleave the list into two parts
` # Pop and push both parts separately to the stack
( # Negate the values in the top list
.ι # Interleave the two lists back together
} # Close the map
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 25 bytes
```
ＮθＷ⁻↨⮌υ±¹θ≔Ｅθ⊕‽θυ⭆υ⁺§+-κι
```
[Try it online!](https://tio.run/##FY07DoMwEET7nMKiWiumSBlRkY4ChOAEDqzAilnwj@T2zlLNFG/eTKv2065tzg0dKXZpe6MHJ6vbdzUWBbSGUoCXDggDnug5k1Siw0VHhIfk7qQUdQhmIWj1AU6JhiaPG1LEGQZN876x8kITi3tvKMIYOZaLT0r0lj/q2NCMPyjuZaHEh2nDmyrnZy5P@wc "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input `N`.
```
Ｗ⁻↨⮌υ±¹θ
```
Until interpreting the reverse of the predefined empty list as base `-1` results in `N`, ...
```
≔Ｅθ⊕‽θυ
```
... assign `N` random integers in the range `1..N` to the list.
```
⭆υ⁺§+-κι
```
Output the list with `+` and `-` signs inserted as appropriate.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 20 bytes
```
s+V*"+-"QOf!u-HGTQ^S
```
[Try it online!](https://tio.run/##K6gsyfj/v1g7TEtJW1cp0D9NsVTXwz0kMC74/39jAA "Pyth – Try It Online")
### Explanation
```
s+V*"+-"QOf!u-HGTQ^SQQ # Implicitly add QQ
# Implicitly assign Q = eval(input())
SQ # range(1, Q+1)
^ Q # repeated cartesian product, Q times
f # filter over lambda T
u-HGTQ # reduce T over subtraction with Q as the starting value
! # true if 0
O # choose a random value from the list
+V # vectorized addition with
*"+-"Q # "+-" repeated Q times
s # join into one string
```
[Answer]
# JavaScript (ES6), 74 bytes
```
f=(n,i,s)=>i^n?f(n,-~i,[s]+"+-"[i&1]+-~(Math.random()*n)):eval(s)-n?f(n):s
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYjTydTp1jT1i4zLs8@DcjTrcvUiS6O1VbS1lWKzlQzjNXWrdPwTSzJ0CtKzEvJz9XQ1MrT1LRKLUvM0SjW1AVr0rQq/p@cn1ecn5Oql5OfrpGmYaypyYUqYoIhYqqp@R8A "JavaScript (Node.js) – Try It Online")
### Commented
```
f = ( // f is a recursive function taking:
n, // n = input
i, // i = counter, initially undefined
s // s = output string, initially undefined
) => //
i ^ n ? // if i is not equal to n:
f( // do a recursive call:
n, // pass n unchanged
-~i, // increment the counter
[s] + // append to s ...
"+-"[i & 1] + // ... either "+" or "-" according to
// the parity of i
-~( //
Math.random() // followed by a random integer
* n // in [1, n]
) //
) // end of recursive call
: // else:
eval(s) // evaluate the expression
- n ? // if the result is not equal to n:
f(n) // try again
: // else:
s // stop and return it
```
[Answer]
# C (gcc), ~~118~~ 112 bytes
*-6 bytes, thanks to @Arnauld*
```
i=0,s=0,a[];f(n){for(s=0;s-n;)for(i=s=0;i<n;)s+=a[i++]=(i%2*2-1)*~(rand()%n);for(i=0;i<n;)printf("%+d",a[i++]);}
```
[Try in online!](https://tio.run/##NY5BC4MwDIX/ihQKia3g3E6L/SXOQ9E5cjAb1pu4v97VqYcEvsd7L@mKV9fFyK60IY1vWhpAcBneEySBQiGEG7DbkOuEwTjfsDGtA9ZVXhUXzL8weekBtSDt9sP8mVjmAZQ2vbJ7DGmNo2cBXMI/NfP4hBKPpMyZuCtJfUvLGFzOCnG6v2fKbifSj3TqD1Gpco0/)
] |
[Question]
[
Now that we know how to [Square a Number my Way](https://codegolf.stackexchange.com/questions/136564/square-a-number-my-way), we need an inverse operation, a way to Square Root a Number my Way. To square a number my way, you simply stack it on top of itself a number of times equal to the number of digits it contains, and then take read off every number that is formed both vertically and horizontally, and then add them together. More information about squaring a number in this manner can be found [here](https://codegolf.stackexchange.com/questions/136564/square-a-number-my-way). To square root a number my way, you simply take the number that has the least decimal digits that squares (my way) to make the number you are square rooting. For example, since 12 can be formed by squaring 6, and there are no numbers with fewer decimal digits that can be squared to form 12, the square root of 12 is 6.
## Your Task:
Write a program or function that takes an integer and square roots it as outlined above.
## Input:
An integer or string
## Output:
A float or string square rooted as outlined above.
## Test Cases:
```
1263 -> 125
57 -> 12
```
## Scoring:
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), lowest score in bytes wins!
[Answer]
# [Python 2](https://docs.python.org/2/), 101 bytes
Ports from my [answer to square the numbers my way.](https://codegolf.stackexchange.com/a/136581/59523)
```
x,z=1,input()
while sum(float(i*len(z))for z in[[i for i in`x`if"/"<i]]for i in[x]+z)!=z:x+=1
print x
```
[Try it online!](https://tio.run/##NcixCoMwEADQ3a@4OiVVkCh0KM2XhIAdDB7ES7CRXu/nYzt0e7z8KWuisVbuxZoeKR9F6ea9YlzgdWwqxPQsCq9xISVah7SDAJJzCD/j1zPPGNqhfaD3/3PsO9EXK3furGnyjlSAazXjbToB "Python 2 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 112 bytes
```
f=lambda x,k=0:k if(lambda x:int(x)*len(x)+sum(map(int,map(''.join,zip(*[x]*len(x))))))(str(k))==x else f(x,k+1)
```
[Try it online!](https://tio.run/##NY1NCsIwGESvkl3na4NYCy4KOUlxETHBmJ@GJkL08jEVnc2DxzATX/m@hqlWLZz015tkhVtxnC0zGn8zm5BRqHcqNAzp6eFlRLN8Z9cdHqsJ/G0i@qVcfr1vkPIGSyREYcolxTTawTBSjdu@qjGezhNR/QA "Python 3 – Try It Online")
[Answer]
# Mathematica, 130 bytes
```
(For[i=1,(t=Length[s=#&@@RealDigits[#]//.{a___,0}:>{a}];If[IntegerPart@#==0,t++];t#+Tr[FromDigits@Table[#,t]&/@s])&[i]!=#,i++];i)&
```
other test cases
>
> 5994 -> 999
>
> 79992 -> 9999
>
> 999990 -> 99999
>
>
>
[Answer]
# [Pyth](https://pyth.readthedocs.io), 20 bytes
```
xms+RdsM*RF_lB@jkUT`
```
**[Test Suite.](http://pyth.herokuapp.com/?code=xms%2BRdsM%2aRF_lB%40jkUT%60&input=1263&test_suite=1&test_suite_input=1263%0A57&debug=0)**
As all the other answers, this assumes the input is a "perfect square (my way)". This also uses the fact that the square (my way) of an integer is always higher than or equal to itself. Also, this is a port [of Erik's solution](https://codegolf.stackexchange.com/a/136575/59487) to that challenge. Porting my solution from that challenge would result in a longer submission.
[Answer]
# PHP, ~~92 90 89~~ 84+1 bytes
brute force (assuming that the input is a perfect square)
using [my solution](https://codegolf.stackexchange.com/a/136603/55735) from [Square a Number my Way](https://codegolf.stackexchange.com/questions/136564/square-a-number-my-way):
```
while((0|$k/=10)||$s-$argn&&$k=++$n+$s=0)$s+=$n+str_repeat($k%10,strlen($n));echo$n;
```
Run as pipe with `-nR` or [try it online](http://sandbox.onlinephpfunctions.com/code/56f8984b96e33ad75e2ff10e622b316a2faa4997).
] |
[Question]
[
**This question already has answers here**:
[Write a program that reverses the name of its source file](/questions/82635/write-a-program-that-reverses-the-name-of-its-source-file)
(30 answers)
Closed 7 years ago.
Write a program that prints the name of its source file. REPL environments are not allowed for this challenge. Your code must work in any file that your language's interpreter will accept. Your answer must also be a full program, not just a function. The source code's file extension must be printed. Leading or trailing newline are both optional. This is a code golf, so shortest answer wins. The winner will be chosen on September 2nd, 2016.
[Answer]
# [V](http://github.com/DJMcMayhem/V), 3 bytes
```
"zp
```
[Try it online!](http://v.tryitonline.net/#code=Inpw&input=)
This actually *does* work in the online interpreter somehow. `¯\_(ツ)_/¯`
Explanation:
The 'z' register is predefined to the source file of the program, and `p` pastes from whatever register you tell it to. `P` would also work, and not cause any different output.
[Answer]
# Bash, 7
```
echo $0
```
So trivial, I have to type in this text to make the answer long enough.
[Answer]
# C, 23 bytes
```
main(){puts(__FILE__);}
```
[Try it on Ideone](https://ideone.com/15AST1)
] |
[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/18322/edit).
Closed 3 years ago.
[Improve this question](/posts/18322/edit)
I'm creating a simple challenge here as a first test of the community's reactions. Please let me know if this challenge is the kind of thing you guys like or what I can improve... :)
The task is this: Render a chess board in Lua in smallest code possible.
Here is an example solution: <http://tinybrain.de/145>
As you can see, there is definitely room for getting smaller than 657 bytes (# of bytes are printed on the page). All the information you need for coding should be on the page or, hopefully, on tinybrain.de. Mailed questions totally welcome too. Lua API overview: <http://tinybrain.de:8080/tb/debug.php?cmd=144>
I am not demanding your chess board to have the exact same colors or even the same size. It should look like a chess board, that's all.
You need to register on TinyBrain.de to submit and test code. (Sorry, hope that is OK... It's free and I'm not a data peddler, so no harm there... :)
Edit: For testing your code locally (without any registration or Internet connection), you can download the TinyBrain runtime (magic.jar). Here is the link: <http://tinybrain.de:8080/magic.jar>
[Answer]
For a *fancy* ASCII art solution:
```
print("/"..("-"):rep(32).."\\")for y=0,15 do print("|"..(".... "):rep(5):sub(1+(y-y%2)*2%8):sub(1,32).."|")end print("\\"..("-"):rep(32).."/")
```
At 145 characters.
For a *small* ASCII art solution:
```
for i=1,8 do print(("# "):rep(9):sub(i,i+7))end
```
At 47 characters.
[Answer]
Starting with col6y's "small ASCII" solution (47):
```
for i=1,8 do print(("# "):rep(9):sub(i,i+7))end
```
sometimes brute force is better (43):
```
for i=1,4 do print("# # # # \n # # # #")end
```
:)
[Answer]
## 38
Combining 14921's and col6y's ideas:
```
print(("# # # # \n # # # #\n"):rep(4))
```
[Answer]
## 83 characters
This snippet takes advantage of the description's offer to omit one of the dimensions, and to use a single integer to represent the pixel color.
```
w=256
p={}
for i=0,65535 do p[i+1]=5595493-((i-i%32)/32+(i-i%8192)/8192)%2*26214 end
```
(The character count doesn't include the newline on line 2, which I've included solely for legibility.)
The logic is pretty straightforward. The expression `(i-i%32)/32` is equivalent to `math.floor(i/32)` -- in other words, integer division. Written in C's bitwise operators (which Lua lacks), the logic would look like this:
```
p[i] = (((i >> 5) ^ (i >> 13)) & 1) ? dark : light
```
This solution should produce identical output as the example given in the description.
You can shave off several characters by changing the colors to pure black and white, assuming `-1` can be used to represent the white color:
```
w=256
p={}
for i=0,65535 do p[i+1]=((i-i%32)/32+(i-i%8192)/8192)%2-1 end
```
If I also change the size to be 64x64 (which the description permits), I can bring it down to 65 characters:
```
w=64
p={}
for i=0,4095 do p[i+1]=((i-i%8)/8+(i-i%512)/512)%2-1 end
```
However, the description doesn't seem to have any *objective* limits as to the chessboard's appearance. (Rookie mistake.) Let's go ahead and use the color `0x000000` for the white squares, and `0x000001` for the dark squares. And let's have the chessboard squares be 1x1. I can then bring it down to 48 characters:
```
w=8
p={}
for i=0,63 do p[i+1]=(i+(i-i%8)/8)%2 end
```
Or, if we forgo graphics entirely and stick to ASCII, we can use this 54-character solution and still be legible:
```
for i=1,8 do print(('* * * * *'):sub(1+i%2,8+i%2))end
```
[Answer]
**27-29 letters :-þ**
supersmall diagonal but not ascii ..
```
print(("♦♦♦♦♦♦♦♦\n"):rep(5));
```
3D version 35 letters :)
```
print(("◄►◄►◄►◄►◄►◄►◄►\n"):rep(8));
```
extra nice version :)
```
print(("▇ ▇ ▇ ▇\n ▇ ▇ ▇ ▇\n"):rep(4));
```
] |
[Question]
[
**Just-in-time edit**: I decided to reveal part of the answer and highlight a single aspect of the challenge.
---
Show how 4 weights, of 1, 3, 9, and 27 lbs. can be used to produce "weight differences" from 0 to 40 lbs.
You have a two - pan balance scale.
We define the **difference in pan weights** as the total weight placed on the left pan minus the total weight on the right pan.
The difference in pan weights for the empty scale is 0 lbs.
You have 4 rocks, a,b,c, and d, weighing 1, 3, 9 and 27 lbs respectively
Show how you can produce all integer weight differences from 0 to 40 lbs.
**Simpler example**:
*Problem*: With weights of 1 and 3 lbs. show how you can generate all weight differences from 0 to 4 lbs.
*Output*: for `a=1`, `b=3`;
>
> 
>
>
>
---
For the 4 weight, 40 pound version, your output should consist of
a table with columns displaying the weight difference, the symbolic amounts in each pan, and the absolute weights in each pan.
You may format the table in a way congenial to the language you are coding in.
*Scoring*: Shortest code wins
*Bonus*: 50% of your score if the same code can present the results for the case where 3, 4, and 5 weights are used (for 13, 40, and 121 lbs.)
[Answer]
## APL 198 \* 50% = 99
```
z←W n
l←⍉(n⍴3)⊤w←0,⍳+/b←3*0,⍳n-1
r←(⍴l)⍴0
:while 0≠+/+/l>1
r←r+l>1
l←((l≤1)×l)+1⌽l>1
:end
a←' ',⌽⎕av[97+⍳n]
c←(⍴l)⍴⍳n
b←0,⌽b
z←l≠r
l←z×l
r←z×r
l←1+l×c
r←1+r×c
z←w,'{',a[l],'}','{',a[r],'}','{',b[l],'}','{',b[r],'}'
```
As we are effectively working in base three the arithmetic is fairly trivial and is complete by the end of the while loop where the arrays l and r are the contents of the left and right scale pans respectively in base three. This takes about 80 characters. The rest is formatting the output which I am sure can be improved.
To run simply type W followed by the number of weights you want to use. Below is a sample output for n=3:
```
W 3
0 { }{ }{ 0 0 0 }{ 0 0 0 }
1 { a}{ }{ 0 0 1 }{ 0 0 0 }
2 { b }{ a}{ 0 3 0 }{ 0 0 1 }
3 { b }{ }{ 0 3 0 }{ 0 0 0 }
4 { ba}{ }{ 0 3 1 }{ 0 0 0 }
5 {c }{ ba}{ 9 0 0 }{ 0 3 1 }
6 {c }{ b }{ 9 0 0 }{ 0 3 0 }
7 {c a}{ b }{ 9 0 1 }{ 0 3 0 }
8 {c }{ a}{ 9 0 0 }{ 0 0 1 }
9 {c }{ }{ 9 0 0 }{ 0 0 0 }
10 {c a}{ }{ 9 0 1 }{ 0 0 0 }
11 {cb }{ a}{ 9 3 0 }{ 0 0 1 }
12 {cb }{ }{ 9 3 0 }{ 0 0 0 }
13 {cba}{ }{ 9 3 1 }{ 0 0 0 }
```
[Answer]
## Python, 160 \* 50% = 80
```
def f(n):
for i in range(3**n/2+1):g=lambda z:'+'.join(`3**x`for x in range(n)if(i+3**x/2)/3**x%3==z)or'0';print i,'[%s, %s]'%(g(1),g(2)),map(eval,(g(1),g(2)))
```
Shows how each weight difference can be produced, given 'n' different weights.
[Answer]
## Python ~~124~~ 107 bytes \* 50% = 53.5
```
f=lambda i,e=1:i and[e]*(i%3>1)+f(-~i/3,e*3)or[]
for i in range(3**4/2+1):r=f(-i),f(i);print i,map(sum,r),r
```
For different numbers of stones, replace the `4` in `range(3**4/2+1)` with any positive integer.
Sample output:
```
0 [0, 0] ([], [])
1 [1, 0] ([1], [])
2 [3, 1] ([3], [1])
3 [3, 0] ([3], [])
4 [4, 0] ([1, 3], [])
5 [9, 4] ([9], [1, 3])
6 [9, 3] ([9], [3])
7 [10, 3] ([1, 9], [3])
8 [9, 1] ([9], [1])
9 [9, 0] ([9], [])
10 [10, 0] ([1, 9], [])
11 [12, 1] ([3, 9], [1])
12 [12, 0] ([3, 9], [])
13 [13, 0] ([1, 3, 9], [])
14 [27, 13] ([27], [1, 3, 9])
15 [27, 12] ([27], [3, 9])
16 [28, 12] ([1, 27], [3, 9])
17 [27, 10] ([27], [1, 9])
18 [27, 9] ([27], [9])
19 [28, 9] ([1, 27], [9])
20 [30, 10] ([3, 27], [1, 9])
21 [30, 9] ([3, 27], [9])
22 [31, 9] ([1, 3, 27], [9])
23 [27, 4] ([27], [1, 3])
24 [27, 3] ([27], [3])
25 [28, 3] ([1, 27], [3])
26 [27, 1] ([27], [1])
27 [27, 0] ([27], [])
28 [28, 0] ([1, 27], [])
29 [30, 1] ([3, 27], [1])
30 [30, 0] ([3, 27], [])
31 [31, 0] ([1, 3, 27], [])
32 [36, 4] ([9, 27], [1, 3])
33 [36, 3] ([9, 27], [3])
34 [37, 3] ([1, 9, 27], [3])
35 [36, 1] ([9, 27], [1])
36 [36, 0] ([9, 27], [])
37 [37, 0] ([1, 9, 27], [])
38 [39, 1] ([3, 9, 27], [1])
39 [39, 0] ([3, 9, 27], [])
40 [40, 0] ([1, 3, 9, 27], [])
```
The basic operating principle, is that the problem is analog to converting a number into ternary. In Python, this is a one liner:
```
f=lambda i:i and i%3+f(i/3)*10
```
Of course, we're working in a slightly different base. Instead of the values `0, 1, 2` we use `-1, 0, 1`. This means when `i%3 == 2`, this should really be `-1` (calculated by `(i+1)%3-1` or `-~i%3-1`), and the value of the `i` sent to the next iteration needs to be adjusted accordingly.
More specifically, if `d=(i+1)%3-1`, then the value of `i` sent to the next iteration should be `(i-d)/3`. However, this calculaion can be simplified greatly using integer division, to just `(i+1)//3`. Rationale: if `d == 0`, then `i` was already a multiple of `3`, and adding one won't change the integer quotient. If `d == 1`, then we should be subtracting `1` to make `i` a multiple of 3, but if we add `1` instead, it will now be `2 (mod 3)`, which won't change the integer quotient either. If however `d == -1`, then we do in fact need to add `1` to reach the next multiple of `3`. Therefore, by using integer division, all three cases can be simplified to adding `1`.
One thing that makes this problem interesting is that the negative and positive values need to be separated into different baskets. I decided the best way to accomplish this is to only collect the positive values, and then call the function again with `-i`, which will obviously have its stones reversed. This also allows me to save the `-~i%3` calculation entirely, since I know what its value will be.
[Answer]
## Perl, 201 (or 166) chars + 50% bonus = 100.5 (or 83)
eek, brute forcing this turned out to be more complex than i anticipated. im interested to see others' certainly more analytical approaches
change the problem size by modifying the value of `$j` defined at the top to 3, 4, or 5.
this will demonstrate *all* ways to generate the differences, not any pairs in particular.
some additional characters are used to print the differences in order. otherwise, you can remove the outer `for$n(0..$s){}` loop and the `$$x[$j]-$$_[$j]==$n` test to save 14+21 chars for a total of 166 chars.
```
$k=($j=4)-1;@a=map{$s=0;$s+=$_ for@$_;[@$_,$s]}map{$c=$_;[map{$c&1<<$_&&3**$_}0..$k]}0..2**$j-1;for$n(0..$s){for$x(@a){$$x[$j]-$$_[$j]==$n&&print"$n {@$x[0..$k],@$_[0..$k]} {$$x[$j],$$_[$j]}",$/for@a}}
```
or slightly more formatted (no more readable):
```
# set $j to the problem domain size
$k = ($j = 4) - 1;
# gather up all possible combinations and their sums
@a = map{ $s=0; $s+=$_ for @$_; [@$_,$s] } map { $c=$_; [map { $c & 1<<$_ && 3**$_ } 0..$k] } 0 .. 2**$j-1;
# walk through the pairs of combinations and find the differences
for $n (0..$s)
{
for $x (@a)
{
$$x[$j] - $$_[$j] == $n &&
print "$n {@$x[0..$k],@$_[0..$k]} {$$x[$j],$$_[$j]}", $/ for @a
}
}
```
] |
[Question]
[
**Introduction**
In the United States, national elections are normally held on the first Tuesday after the first Monday in November.
**Challenge**
Write a program that takes a Year as integer, and a pair of (day of week as character and ordinal as integer) and output the date as "yyyy-mm-dd"
Remember, the second pair is after the first pair.
use this for inspiration: [https://codegolf.stackexchange.com/questions/178227/get-the-date-of-the-nth-day-of-week-in-a-given-year-and-month[][1]](https://codegolf.stackexchange.com/questions/178227/get-the-date-of-the-nth-day-of-week-in-a-given-year-and-month%5B%5D%5B1%5D)
**Example Input and Output**
Example input:
* 2021 November Tuesday 1 Monday 1
* 2020 November Tuesday 1 Monday 1
* 2020 December Friday 2 Wednesday 1
* 2019 April Wednesday 1 Friday 1
* 2023 February Tuesday 4 Wednesday 1
* 2023 February Wednesday 5 Thursday 1
* 2022 December Sunday 5 Sunday 55
Expected output:
* "2021-11-02"
* "2020-11-03"
* "2020-12-11"
* "2019-04-10"
* "2023-02-28"
* "NA"
* "NA"
Note: the output indicated as "NA" could be any negative finding such as null, but not an error.
[1]: [Get the date of the nth day of week in a given year and month](https://codegolf.stackexchange.com/questions/178227/get-the-date-of-the-nth-day-of-week-in-a-given-year-and-month)
[Answer]
# JavaScript, ~~102~~ ~~93~~ ~~91~~ ~~88~~ ~~80~~ ~~78~~ 77 bytes
Oof, this made my brain itch. Possibly still some room for improvement.
```
(m,t,x=0)=>g=w=>(d=new Date(...m,++x)).getDay()-w[0]||--w[1]?g(w):w!=t?g(t):d
```
[Try it online!](https://tio.run/##jY7BisIwEEDv@xXuLYPTkKT2oBBl11bsxRXFvdSCxcayi7aiwSj47zWhxyWwpzcwjzfzW9yK6/7yc9ZB3ZSqPciWnFDjXTKQ40oaOSalrJXpxYVWhFJ6wn7/DkArpePiQSAwGcufz8CS55OKGBiZd6ntpGFUtvumvjZHRY9NRQ4kE0xw5CzHTCDPgWTcAd7@auzfGrdahMJpoUfjQwytFXaxyBdze3dy4GnttvVmsV4m03SWJnHvM5l/fKdfm9XOHwsxcrGB76To/medZmEJ7Qs)
Call with `f([y,m],[W,O])([w,o])`, where:
* `y` is the year,
* `m` is the 0-indexed month,
* `W` is the 0-indexed target weekday (`0`=Sunday),
* `O` is the ordinal of `W`,
* `w` is the 0-indexed starting weekday, and,
* `o` is the ordinal of `w`
**EDIT:** Looking at the rest of the solutions coming in, they seem to be interpreting the I/O requirements of the spec a *lot* more strictly than I am. After a few read-throughs, I'm not seeing that strictness, nor would it be reasonable to assume it's that strict. Still, though, seeing as I appear to be the only one taking the requirements *this* loosely, I'll take a stab at an alternative solution on Tuesday. (It's a bank holiday weekend in Ireland)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~439~~ 428 bytes
* -11 thanks to ceilingcat
Most of the code is parsing the input.
```
#define z(d)(*d-83?*d-84?*d-77?*d-87?5:3:1:d[1]-117?4:2:d[1]-117?6:0)
#define Z(d,e)(d-e+(d<e?7:0))
t[20],a,b,n,x,y;char*m,*d,*e;f(s){sscanf(s,"%d %ms %ms %d %ms %d",&y,&m,&d,&a,&e,&b);t[5]=y-=1900;x=*m-78;t[4]=n=x+4?~x?x+13?x+8?x-5?x-1?x?11:10:9:8:1:m[1]-112?7:3:m[2]-114?2:4:m[1]-97?m[2]-110?6:5:0;t[3]=1;mktime(&t);t[3]+=Z(z(e),t[6])+(a+b-2)*7+Z(z(d),z(e));mktime(&t);t[4]-n|t[5]-y||printf("%04d-%02d-%02d",y+1900,n+1,t[3]);}
```
[Try it online!](https://tio.run/##jVBdb5swFH3nV1xRBdlgJsxHSaAMTZr61PVlnSY14gGws6AVpwJTQZvsr2cmJE2m7WEPvjr3nHOvfVzaP8pyv79ifFUJDq@IYWQye@6lY/XHGoYHHKZB5EU0Ykua2ZSGqR@55@Y6crB22vKIGOEYMZtbiN3wNFQi1uTSdTKSk4II0pMhLtd5Y9bEZMTk8Qq1@K1ty1woRPQZg1ndTucImU6MgRg1MRgxcmJwYhQ4lssgSwY7oQvHifvErO1wrkg/S0TSW376q097i3qqzNPeDtShaZ9SGlEnWkRzlaeeIrjqlZ5q3LHxUzfyJ2URpkfSUSGDyFHbvSyhcf1TVjVHhsQHxkoe0SvimMjldYYtlFuF7WIztEaaYTJq@M8hP7PFdgxgD9vtc1MJuUL6zPGZPXPcqehksMZoRFiUjNfgeLe/qkT51DEON61kT1XxYf1R09Q01Hkl0MumYhjeNIByI1oJ4zeD2S6zZOQAdNdxKdxvXnhd8AYeOt6yfAAKXzbiAHTy7nP@2/eZl5PvtqlG1YXvnInjyNlJF/BJJX26VE8jlws9uOVF0@XN8H6x/@@Nl9azIYCHddf85XXP7/zaicl4AsHRd//t7k6BHQHTlLGm4GrTIJm0MagenjvZIl3HGFbIlJaFY223/w0 "C (gcc) – Try It Online")
Ungolfed:
```
// Day of week: Su=0, M=1, Tu=2, W=3, Th=4, F=5, Sa=6
#define z(d)(*d-'S'?*d-'T'?*d-'M'?*d-'W'?5:3:1:d[1]-'u'?4:2:d[1]-'u'?6:0)
// Add one week if the target day of week precedes the current one
#define Z(d,e)(d-e+(d-e<0?7:0))
t[20], // struct tm for time conversions (important parts are initialized each run through)
a, b, // week numbers
x, // temporary for month calculation
n, y; // month and year
char *m, *d, *e; // original string versions of days, month and year
f(int*s) {
sscanf(s,"%d %ms %ms %d %ms %d",&y,&m,&d,&a,&e,&b); // get the parsed data
t[5]=y-=1900; // adjust the year
x=*m-78; // get most values into single-digit
// Month: Ja=0 F=1 M_r=2 Ap=3 M_y=4 J_n=5 J_l=6 Au=7 S=8 O=9 N=10 (else) 11
//t[4]=n=*m-'J'?*m-'M'?*m-'A'?*m-'F'?*m-'S'?*m-'O'?*m-'N'?11:10:9:8:1:m[1]-'p'?7:3:m[2]-'r'?2:4:m[1]-'a'?m[2]-'n'?6:5:0;
t[4]=n=x+4?~x?x+13?x+8?x-5?x-1?x?11:10:9:8:1:m[1]-112?7:3:m[2]-114?2:4:m[1]-97?m[2]-110?6:5:0;
t[3]=1; // start on the first day of the month
mktime(&t); // get the day of week information
t[3]+=Z(z(e),t[6])+(a+b-2)*7+Z(z(d),z(e)); // add offsets
mktime(&t); // convert to canonical form
t[4]-n|t[5]-y?printf("%04d-%02d-%02d",y+1900,n+1,t[3]); // only print date if it is still inside the month
}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 204 (or 126?) [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
With strict I/O and outputting `NA` when the date goes beyond the given input month+year: **204 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)**:
```
"Y`т‰0Kθ4ÖUD<i\28X+ë<7%É31α}‹iY¬>0ëY1¾ǝDÅsD12‹i>1ë\1Dǝ¤>2}}ǝV"ˆ$”‚應…ä†ï€¿…Ë…ê†Ä…æ…Ì…Í……”#s#©1èk>Dˆ®н)V®2ô¦RvyθFNĀi¯н.V}[Y`UD3‹©12*+>₂*T÷®Xα©т%D4÷®т÷©4÷®·(O7%”ŒÍ‹Ó‹ŽŒ¹ŒêŒÛŠ¯”#yнkQ#¯н.V]YÂT‰J'-ýsÅs¯θÊi„NA
```
The cumbersome I/O and 05AB1E's lack of date builtins make for a pretty big program. üôÉ
[Try it online](https://tio.run/##JZBdSwJBFIb/yqJJpRTOKtiFLARLF0VGoeKSgUp7sUgJLQleLAxLBX3dGHRRbBjIkh@4CYF6sQVzWrwQFv0L80e2GYM5D@95YeY9c2p6uaKpQRBSSguT4s/4nj9OwnNOTmtFcasQg146FYHbBPKHBsUTTSF9KQ49BZHvqSXDtS4jkfsSgl4RyVOLtCXRMKZWPjS7WaHYovgFbIrf2dsU29CmuAUONfvkh7f3HF3uXXFlczxwPDIsjxXWw6SD4KMqybMbMpi763kyEOGL2Ef1hj/eyfxijThzdzNvHCulnJxg47ALYjQmUdOMZmFEBgV/SDoLMyInebcwGTtLSUZrB6kIS/GaPHICTwye6zXJhDldVq9eizh8jMbcrR6G/5NOFDCz7Ee7qxvg6mwLxPHHcKdR/JbZDgIxLiIhU6urZxX1QsheqvppuSEgYb92vhR/) or [verify all test cases](https://tio.run/##hZHva9NAGMff56842hV10625dkwhZAxiXyh2qF1dsYJpc9CwmYxknfRFIAQt@OtNBV8okQmj2HW0DgZrX0ThztIXg9D@C/eP1Lt0s2NvBnffPPe9T57nubuSalcmZXUXyKBsamjRtNWSjoAkgfvrGWE1Bmi9AWKrk1ih@HLsUfdX8mHYS5MvG4qkF@HdzQXSllYS5F1KDI8d6vb1Aj6Sk6RdEPHvoa@Qt7YiQu7LImkXRWXo4wMZOs7Qz8fO6nPU9an7lTSp@4Plpm6THFB3n3Spd4T/8OUHLofce8OjJpePXD4xiYYft@O4JZKfW7JyVsedUXArjzuQnODmk71a2Mtk/7o67o6CxbzznJ1iQ0mxftgfcH5Bpp43nyOnuLMZHuPW2Esoab4ae0xbUYhPb66vJFiZQYPX7JPPTAbBoIH7zDlk89tgH3d5H7VRsPU4Pi31okC8HDvSgxt3SGCza8DdsEfe69T9nl2bOLfxicAvWHhd0bcRsJCqAd0QNFMAYMnc2V2avsP558rTSGAuYg00gUkogqy5h16VkAVyVWRrag2I4JFpRIHAgOT1gILKUyBj6dyG4BnSjHOWIeI9sLZj6duX7Qs2SpECGVSyqqpV@18jfSXHZWa2swxylao1g@Csl6dVY0pcBMvCPw).
With flexible I/O and just continue calculating instead of outputting `NA`: **126 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)**:
```
"Y`т‰0Kθ4ÖUD<i\28X+ë<7%É31α}‹iY¬>0ëY1¾ǝDÅsD12‹i>1ë\1Dǝ¤>2}}ǝV"ˆ1šVvyθFNĀi¯н.V}[Y`UD3‹©12*+>₂*T÷®Xα©т%D4÷®т÷©4÷®·(O7%yнQ#¯н.V]Y
```
Two inputs in the formats `[month,year]` and `[[weekday2,amount2],[weekday1,amount1]]`, where `month` is an integer `1-12` and `weekday` are integers `0-6` for Saturday to Friday.
Outputs in the format `[day,month,year]`.
Still pretty big with the manual calculations, but apparently more than 1/3rd of my top program's bytes are to deal with just the I/O formats.
[Try it online.](https://tio.run/##yy9OTMpM/f9fKTLhYtOjhg0G3ud2mByeFupikxljZBGhfXi1jbnq4U5jw3Mbax817MyMPLTGzuDw6kjDQ/uOz3U53FrsYmgEErczPLw6xtDl@NxDS@yMamuPzw1TOt1meHRhWFnluR1ufkcaMg@tv7BXL6w2OjIh1MUYqOXQSkMjLW27R01NWiGHtx9aF3Fu46GVF5tUXUxAvItNQHIlmHlou4a/uWrlhb2ByhAzYiP//482NNQxMjAyjOWKjjbWMYzViTYBkrEA)
**Explanation (of the larger strict I/O version):**
Step 0: Create a function to go to the next day, which we'll re-use later on (see [this 05AB1E answer of mine](https://codegolf.stackexchange.com/a/173126/52210) for an in-depth explanation of how we're going to the next day manually of a given date):
```
"Y`т‰0Kθ4ÖUD<i\28X+ë<7%É31α}‹iY¬>0ëY1¾ǝDÅsD12‹i>1ë\1Dǝ¤>2}}ǝV"
# Push this string to act as function later on with an eval
ˆ # Add it to the global array†
```
† The reason I use the global array instead of a variable: I'm already using all three `U/X`, `V/Y`, and `©®` variable setters/getters in the actual manual date calculations.
Step 1: Extract the year and month from the input, and parse it as `[1,m,y]` triplet-list:
```
$ # Push 1 and the input-string
”‚應…ä†ï€¿…Ë…ê†Ä…æ…Ì…Í……”
# Push dictionary string "January February March April May June July August September October November December"
# # Split it on spaces to a list
s # Swap so the input-string is at the top of the stack
# # Split it on spaces as well
© # Store this sextuple input-list in variable `®` (without popping)
1è # Pop and get the Month at (0-based) index 1
k # Get the (0-based) index of this month in the list
> # Increase it by 1 to a 1-based index
DÀÜ # Add a copy to the global array as well
® # Push the input-list of variable `®` again
–Ω # Pop and leave its first item (the year)
) # Wrap all three values into a list: [1,m,y]
V # Pop and store it in variable `Y`
```
Step 2: Parse the remainder of the input-string, and start looping:
```
® # Push the input-list from variable `®` again
2ô # Split it into parts of size 2
¦ # Remove the first part (the [year,"Month"])
R # Reverse the other two parts
v # For each over the pairs `y` in the pair:
yθ # Push the last item of the current pair (the amount of days)
F # Pop and inner loop that many times:
NĀi # If it's NOT the first iteration:
¯н.V # Go to the next day
# by evaluating the first item of the global array of step 0
} # Close the if-statement
[ # Start an inner infinite loop:
```
Step 3a: Calculate the DayOfWeek of the current date as `[0,1,2,3,4,5,6]` for `[Saturday,Sunday,Monday,Tuesday,Wednesday,Thursday,Friday]` respectively (see again [this 05AB1E answer of mine](https://codegolf.stackexchange.com/a/173126/52210) for an in-depth explanation of how I calculate the Day of the Week manually of a given date):
```
Y`UD3‹©12*+>₂*T÷®Xα©т%D4÷®т÷©4÷®·(O7%
```
Step 3b+c: If this day is equal to the input-date of the current pair `y`, stop the infinite loop. If not, go to the next day and continue looping.
```
”ŒÍ‹Ó‹ŽŒ¹ŒêŒÛŠ¯” # Push dictionary string "Saturday Sunday Monday Tuesday Wednesday Thursday Friday"
# # Split it on spaces to a list
y–Ω # Push the first item of the current pair (the day)
k # Get its 0-based index in the list of weekdays
Q # Check whether it's equal to the calculated DayOfWeek from step 3a
# # If they're equal:
# # Stop the inner infinite loop
¯н.V # (Else) Go to the next day by evaluating step 0 again
```
Step 4: Format the resulting date to the desired output-format:
```
] # Close the three loops
Y # Push the resulting date `Y`
 # Bifurcate this triplet; short for Duplicate & Reverse copy
T‰J # Format the day/month with leading 0:
T‰ # Divmod each inner value by 10
J # Join each inner pair together
'-√Ω '# Join the triplet-list with "-" delimiter
s # Swap the triplet to the top of the stack again
√Ös # Only leave its middle item (the month)
¯θ # Push the last item of the global array (the parsed input-month)
Êi # If they are NOT equal:
„NA # Push string "NA"
# (after which the top of the stack is output implicitly as result)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `”‚應…ä†ï€¿…Ë…ê†Ä…æ…Ì…Í……”` is `"January February March April May June July August September October November December"` and `”ŒÍ‹Ó‹ŽŒ¹ŒêŒÛŠ¯”` is `"Saturday Sunday Monday Tuesday Wednesday Thursday Friday"`.
Both `"ˆ$”‚應…ä†ï€¿…Ë…ê†Ä…æ…Ì…Í……”#I#1èk>` and `”ŒÍ‹Ó‹ŽŒ¹ŒêŒÛŠ¯”#yнk` can probably be golfed a bit with magic numbers of some sort, but since I suck at those and I also couldn't really be bothered in an answer already this big because of manual date calculations, the indexing into dictionary strings will do for now.
[Answer]
# [Go](https://go.dev), 262 bytes
```
import."time"
func f(y,m,d,e string,n,o int)string{t,_:=Parse("2006January",y+m)
D,i,j:=Hour*24,1,1
for t.Weekday().String()!=e{t=t.Add(D)}
for;j<o;j++{t=t.Add(D*7)}
for t.Weekday().String()!=d{t=t.Add(D)}
for;i<n;i++{t=t.Add(D*7)}
return t.Format("2006-01-02")}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=hVPRatswFGV7GNRfofnJbmRjKUnX2vWDIQtjsFBIoYwstGqspEptychyWQj5kr2UwR72SdvXTIqcZG0Ze7rXR-ceXd17_O37Qjz-SioyuycLCkrCuMPKSkgVuvNSufuPWknGF_UTYCb4g_ujUfPg9PerN7sDxUrqOvOGz8DcW8ES5pACWw45FIBx5dvPtYLXcXpBZE09F0fRyUfCGyJXLlx1St8ZQAaXcfpBNPIY9yCCyJkLCVR4Rel9TlaeH463Op7_NqVrlaowy3Nv4G8ML1mei2TZ6Rzw43f25B8K-QsFds4T9kJBUtVIrkWGQpZE2c6DCAURdv1NO47XP9WqoiAzD29mCqw_UyIh-CS4uoNgQFaoHUkCRk2JzFASA-M9bHBs8fdfK6o17MnGsbM1q_J8sHZEnN7gCCMwEg-0vKUSXDa01q8DyNxnE0MIkOnR0Wn0P2605XYtd0BnljuUzDAwuKI535VZNtYFmo3OQFZJVjxhtGWGis6CqBegyAh3wZDeSrPvfRO958pd3XCAT5_RD6Q-uLxrZMsfZYaHD_2OG25Ju6SvOTdOHaeTaba2XriGBYhTIAnX9h9XBVOegMD9wl0z2yMap0NGi7z2Ct854sgYNlOCeXTSnRoE_4X0DVKnpKooz70agmy79phOomm7e52jqTWATrFNsU57OjVOiPUd29XHWrrdvD4-mW58Z9cxiVPbb712LrQnVME9AvXfRkJrMxK2RiOhuamN2ERzRxuxbyRbxz4-2vgH)
Extremely similar to my solution for ["Get the date of the nth day of week in a given year and month"](https://codegolf.stackexchange.com/a/257397/77309).
For the `NA` test cases, it continues on to the next month/year until it finds the `n`-th `d`day after the `o`-th `e`day.
### Explanation
```
import."time"
func f(y,m,d,e string,n,o int)string{
t,_:=Parse("2006January",y+m)
D:=Hour*24
```
Some initial setup: getting the 1st of month `m` in the year `y`, and defining a `D`ay variable.
```
for t.Weekday().String()!=e{t=t.Add(D)}
for j:=1;j<o;j++{t=t.Add(D*7)}
```
Skip forward to the `o`-th `e`day.
```
for t.Weekday().String()!=d{t=t.Add(D)}
for i:=1;i<n;i++{t=t.Add(D*7)}
```
Skip forward to the `n`-th `d`day.
```
return t.Format("2006-01-02")}
```
Return a formatted date.
] |
[Question]
[
**This question already has answers here**:
[Build a polyglot for Hello World](/questions/10695/build-a-polyglot-for-hello-world)
(9 answers)
Closed 3 years ago.
Simple challenge: The code must be both valid Lisp and valid Fortran, and must print out "hello world" in both.
Note: I've sunk about 5 hours into this at this point, I'm not even sure it's possible at this point...
Details:
* Must be in a single source file.
* Any version of Fortran and any Lisp are allowed (specify which).
* Smallest source code (by bytes) satisfying this wins.
[Answer]
# [Fortran (GFortran)](https://gcc.gnu.org/fortran/) -ffixed-form, ~~183~~ 53+12=65 bytes
```
;print*,"Hello world!"
;end
*(print "Hello world!")
```
[Try it online!](https://tio.run/##S8svKilKzNNNT4Mw/v/ntC4oyswr0dJR8kjNyclXKM8vyklRVOLitE7NS@HS0gDLKqBKav7//y85LScxvfi/blpaZkVqii7QvFwA "Fortran (GFortran) – Try It Online")
# [Common Lisp](http://www.clisp.org/), 53 bytes
[Try it online!](https://tio.run/##S87JLC74/5/TuqAoM69ES0fJIzUnJ1@hPL8oJ0VRiYvTOjUvhUtLAyyrgCqp@f8/AA "Common Lisp – Try It Online")
] |
[Question]
[
This riddle was inspired by [that thread](https://codegolf.stackexchange.com/questions/53642/every-possible-cycle-length). Consider that you are super-hacker and try to break MD5 hashing algorithm by looking for a hash collisions for a given hash string which your friend gave to you. But this is a non-trivial task and you have a migraine disorder so you try to break the problem into smaller parts. First thing which you try is to look for a [hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) patterns in a repeated execution of MD5() feeding it's last output to an input. For example, if your friend gave to you a hash bb2afeb932cc5aafff4a3e7e31d6d3fb, then you will notice a such pattern :
```
e3b86f8d25e5a71a88eabef0d7ed9840=md5(bb2afeb932cc5aafff4a3e7e31d6d3fb), hamming 95
45fcdb59517b39f18d1622a84be0a301=md5(e3b86f8d25e5a71a88eabef0d7ed9840), hamming 91
0b3f2eac737b916f3b78f240e7fc97ec=md5(45fcdb59517b39f18d1622a84be0a301), hamming 77
fe56b1802722cc30b936186aacce1e01=md5(0b3f2eac737b916f3b78f240e7fc97ec), hamming 95
```
So after 4 iterations you arrived at hamming distance 95 between an output and a first input, which is the same 95 number which you have started from. So nearest hamming cycle period of MD5(bb2afeb932cc5aafff4a3e7e31d6d3fb) is **4**. You have found *a hamming collision* !
Your task is to write a program which takes an arbitrary MD5 hash from the standard input, and outputs it's nearest hamming cycle period on standard output. For example:
```
Input: 45fcdb59517b39f18d1622a84be0a301, Output: 3
Input: 1017efa1722ba21873d79c3a215da44a, Output: 7
Input: edc990163ff765287a4dd93ee48a1107, Output: 90
Input: c2ca818722219e3cc5ec6197ef967f5d, Output: 293
```
Shortest code wins.
Notes:
1. If your language doesn't have an `md5()` built-in, feel free to implement that yourself and then write in the solution *total* byte count and byte count *without* md5() sub-program implementation, the later will be considered as an answer.
2. Hamming distance is defined as number of differing bits between two strings. If strings converted to binary (by character ASCII code) has different lengths - smaller one is padded from the left with 0. Example:
```
Word1: nice Binary1: 01101110011010010110001101100101
Word2: car Binary2: 00000000011000110110000101110010
Hamming distance (differing bits): 12
```
3. In this task you should calculate hamming distance between a **FIRST** input in a cycle and current output. So according to a given hamming cycle example above you should calculate
```
hamming(bb2afeb932cc5aafff4a3e7e31d6d3fb,e3b86f8d25e5a71a88eabef0d7ed9840)
hamming(bb2afeb932cc5aafff4a3e7e31d6d3fb,45fcdb59517b39f18d1622a84be0a301)
hamming(bb2afeb932cc5aafff4a3e7e31d6d3fb,0b3f2eac737b916f3b78f240e7fc97ec)
hamming(bb2afeb932cc5aafff4a3e7e31d6d3fb,fe56b1802722cc30b936186aacce1e01)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 37 bytes
```
Ç,³OBU+0x8¤_/FAS,Ç
Ç;0ịÇƊ$⁺-ịn1ị$Ʋ¿LH
```
[Try it online!](https://tio.run/##PVFBS@NAGL3nXwhpPUwXk8kk1u1FPRQPgrDSPexB16g9SPGgsFQQaUTNUsGle2kEEauxIIqIu2HTeAjMxIA/Y@YP7E@I34wiA5P3fe/NN@9NNtZbrZ0C86fjsgWbvivhXt4tE1nlXU1@y1hR5J2y3im8RWgIeGlCqfbUWX1J0ZoNu@gE7GhxhvVZUOLxuVbN0ixFpuQR8xHrSVQCUqlZX3TO6CUd0pDewVEky4FqDKAsCe8vqKZZD00q/WdoQF9hGsmK9QkqER2a6vIznvxC9WzAR4c8fuTx8bcfonPqYnCtOaCYbSCjbWEaNvjolPk8PkD4w9FCjQXC@1czKmbFaMMw9gBWbmA2DbdJgycnPD7EtuNKMdB57ztP/Pz6pQ9JXy746JZGY02e/Bz/Oj8urwUdBLupGbCEFzMfqsjJUocOZdBregUrfPOuky/ADoUXZSmWfGDDK0QOoQMeXxFE7//HJ9KmCw4aSOzfGW1I5cIbyEwy0tsgFsw9/27VC@ZX6J8FFbhKw@WJ@sxihfka82uGVPl5Vxde8gnwpvo9@SNN5@eKoiB2c3XNtadsc9K1pppmdc10MF6pEnfdWLEM8xU "Jelly – Try It Online")
[Try it online! - using full implementation of MD5](https://tio.run/##PVFBa9RAGL3nXwibLTiV7k4m2bW5tD0sPQQKlnrw0LppNwdZPChIBSkbUCMpKOslKRQxNl0oiod1o9n1EJiJA/0Zkz/gT4jfzC4SmHnf9943897kyWA4fFlj8fu8acDSeCXhGQ@bRFY81OTexIoiK8pYUfgZoSngww2lOlOzjUNFayas1Shmb/e3WcRiXeSftG5ZlAVqSx6xALGxRDqQSs2ianRJv9AJTek3GEWyTFQjgVKv/BmottgYdVFnqfdnfKpmNwGCRmGayYpFBOmkAU1l5FIsPqBemYj5G5FPRX7@6EU1unAxJNAsUOwcoNapgWl6IOYXLBD5a4T/u3NY1HUrfy41XRjYs1lc@b9sxzSPeKhbhIenWy0e2ix4TuBskN6F/ScEgdPLwqITmeWaXsGXLi01yAOgJ5WflQWWfGxC0MwiNNFAzMePxSLg17cRPNztZzH/SrM7nli8W3vorEnn4Avmb2xwTVO78vM2LgvoZNL8FUH0@9/8PZ/Sm9U9o7hDJzINzZzNtsVDmkidi01LxoJ3gIQzCeUjLD2yePfPx2GvZsE6/bG3s4p/tNHb3l9ngcYCuyVVAQ8blb@4B/ip@rlwbeHs1nXturjvDdz7Bj4@Nvt9z/NI3xh0Bkb7xDoxPPcf "Jelly – Try It Online")
I'll comment it when I have time. Jelly doesn't have an MD5 built-in, so the header for the first TIO implements MD5 for a fixed length (32 bytes) input. I've also now extended this to a general purpose MD5 routine (second TIO link). For the purposes of the challenge, there is a monadic link just above the challenge code that takes a 32 character string and returns the MD5 hash. The remaining code (as displayed above here) calculates the hamming distance between the original input and sequential hashes until it matches the first one.
[Answer]
# [Python 2](https://www.python.org/downloads/release/python-272/), ~~199~~ 196 bytes
*-3 bytes thanks to Kevin Cruijssen*
```
from md5 import*
B=bytearray
h=lambda a,b:sum(bin(i^j).count('1')for i,j in zip(B(a),B(b)))
m=lambda a:new(a).hexdigest()
def f(x):
a=b=m(x);i=1
while 1:
b=m(b);i+=1
if h(x,a)==h(x,b):return i
```
[Try it online!](https://tio.run/##VY5LjsIwEETX@BTeYc9EKO3EcZxRNhxkpPaPGJGPTBAwl8@YDRKrLlW/7qrluQ7zJLYtpHmko5M0jsuc1i9y7M1z9ZgSPsnQX3A0DikWprveRmbixOLvmR/sfJtWtoc9D3OisTjTONG/uLAjQ14cmeGck/F93k3@nheHwT9cPPnryjhxPtDAHrwjFHvTj1n@xB4IvQ/x4il0ZPdyTXa/s72LgQ7sUSDv@9c0vEt@vaWJxm1JMbcJbF/LYJ2RWoIylQ7QOmiEwLY2vsSqzHU5ecNQgvIBQQlhUECrKqe0rbKUDusaP2DvrNYlNFUIqpGiVVg7pyvv6xYBSvUBW2GxzQ@FEKB9Za30tgGd03SjgnQZ3v4B)
[Answer]
# perl 5 (`-MDigest::MD5=md5_hex` `-M5.01` `-pl`), 83 bytes
may be golfed
```
$x=$_;$h=(unpack'B*',($x=md5_hex($x))^$_)=~y/1//,$i||=$h while$c++<2|$i!=$h;$_=$c-1
```
[TIO](https://tio.run/##NY/LasMwFAX3/ooWLsRu7FpXD8uK603JNr9QI@tRizqJaVKagOmnV9Wmu2HgDJzFfc4iHu85hBJM0UW49TB0MPX512nR5mPz@rQp82SPVgyTuyUsijcYiv7nXmNdlxDWtYfp4XsKswOz3b7QFcJjUh0MPZgKY@TCGzsKJVCOTHlsLTaU6paPjmhGMEOC0nmNktJRU2wls1IZllBYzbnOnDVKEWyY97IRtJWaW6uYc7zViERmhhrdpiGlFJVjxghnGlSpqhrphf09L9dwPl1iddiHd3e57naHvfh/lax4JhirZf4D)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 157 bytes
```
f=(s,n,a=(B=Buffer)(s))=>a.map((x,i)=>r+=(g=x=>x&&x%2+g(x/2))(x^B(s)[i]),s=require('crypto').createHash('md5').update(s).digest`hex`,r=0)|r==n||1+f(s,n||r,a)
```
[Try it online!](https://tio.run/##Xc5BboMwEAXQfU8RRUpiK5RgG2O8cBZZ9Q5Vqwz2mFAlQA2pqMTdqStlld3M1zzN/4IfGGxo@vG17RwuizdkSNoEDDmZ0917DJQMlJojpDfoCZmSJi5hb0htJnOctttpw/c1mQ6cUjJ9nuL1e/NBk8EE/L43AcnOht9@7HY0tQFhxDcYLmR3czIm997FJJrUNTUO4/mC0zkJJqNzMKadZ7b3/4XmOSRAF9u1Q3fF9NrVxJN1Lr11ldSSqUpoz0rHCs6hzCvMQGRsTenqcFiJlyfHMqbQA1OcV8BZqYRT2oo4Sgd5Dg@nnh06q3XGCuG9KiQvFeTOaYGYl8BYph5OZ8/Qcgtl/MM5ZxqFtRJtwXQsoQvlpXtArsXyBw "JavaScript (Node.js) – Try It Online")
] |
[Question]
[
# Introduction
Given a set of text-based "screenshots" consisting of printable ASCII chars merge them so that all of them form one long screenshot so that nobody has to do it themselves when reading it.
# Challenge
Take input as a list of strings (referred to as "screenshots"). Each screenshot consists of several lines of text.
To merge two screenshots:
1. Starting from the first line, check if that line occurs in the second screenshot
* If it does, cut the first screenshot so it ends at this duplicated line and cut the second screenshot so it begins one line after the duplicated line
* Concatenate these two together with the cuts
2. If they do not have a line of text in common, just append the second screenshot to the first (starting on a new line).
Your output should be a single string merging all of the screenshots together. Screenshot merging is not associative, so you should merge in the following order: merge the first and the second screenshot, then the resulting screenshot with the third, then the result with the fourth screenshot, and so on, until only one screenshot is left.
### Example with explanation
Input:
Screenshot 1:
```
> hi
hi <
> how are you doing
good <
```
Screenshot 2:
```
hi <
> how are you doing
good <
> good
yes <
```
Output:
```
> hi
hi <
> how are you doing
good <
> good
yes <
```
Explanation:
Going from top to bottom, find the first line on both the first and second screenshot
```
> how are you doing
```
Take the first half of this screenshot above and including the line
```
> hi
hi <
> how are you doing
--remove everything below--
```
Find the first line where it is duplicated in the next screenshot and cut one below there
```
--remove everything including and above--
good <
> good
yes <
```
Concatenate the two sections
```
> hi
hi <
> how are you doing
--join them together--
good <
> good
yes <
```
# Test Cases
Input:
```
line 1
line 2
line 3
line 2
line 3
line 4
```
Output:
```
line 1
line 2
line 3
line 4
```
Input:
```
line 1
line 2
line 10
line 10
line 2
line 3
```
Output:
```
line 1
line 2
line 3
```
>
> Note that even though line 10 is duplicated, line 2 is duplicated first and split there.
>
>
>
Input:
```
words
really long repeated words
456
hi
really long repeated words
hmm
really long repeated words
kthxbye
```
Output:
```
words
really long repeated words
hmm
really long repeated words
kthxbye
```
>
> Note that `really long repeated words` appears twice in the result because the one in the first screenshot and the other in the second screenshot is included
>
>
>
Input:
```
======= 10:42 ========
~~~ p1: hi
hi :p2 ~~~
~~~ p1: yes
no :p2 ~~~
v ----------- v
======= 10:43 ========
no :p2 ~~~
~~~ p1: why?
because :p2 ~~~
~~~ p1: ok fine
v ----------- v
======= 10:44 ========
because :p2 ~~~
~~~ p1: ok fine
~~~ ~~~
~~~ ~~~
v ----------- v
```
Output:
```
======= 10:42 ========
~~~ p1: hi
hi :p2 ~~~
~~~ p1: yes
no :p2 ~~~
~~~ p1: why?
because :p2 ~~~
~~~ p1: ok fine
~~~ ~~~
~~~ ~~~
v ----------- v
```
>
> Note that the clock increases in time meaning that the clock is not the first duplicated input. Because it is before the first duplicated input, it gets ignored the second and third time.
>
>
>
### Edge Case Input:
```
> hello
oh hi <
> how are you doing
good <
```
Output:
```
> hello
oh hi <
> how are you doing
good <
```
>
> Note that nothing is duplicated here so just append them together
>
>
>
As this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), smallest submission in bytes wins.
[Answer]
# JavaScript (ES6), 112 bytes
Takes input as a list of lists of lines, outputs a list of lines.
```
s=>s.reduce((a,b)=>(i=a.findIndex(x=>(j=b.indexOf(x))>=0))<0?a.concat(b):a.slice(0,i+1).concat(b.slice(j+1)),[])
```
```
const f =
s=>s.reduce((a,b)=>(i=a.findIndex(x=>(j=b.indexOf(x))>=0))<0?a.concat(b):a.slice(0,i+1).concat(b.slice(j+1)),[])
;
const tests = [
[`line 1
line 2
line 3`,
`line 2
line 3
line 4`],
[`line 1
line 2
line 10`,
`line 2
line 10
line 3`],
[`words
really long repeated words
456`,
`hi
really long repeated words
hmm
really long repeated words
kthxbye`],
[`======= 10:42 ========
~~~ p1: hi
hi :p2 ~~~
~~~ p1: yes
no :p2 ~~~
v ----------- v`,
`======= 10:43 ========
no :p2 ~~~
~~~ p1: why?
because :p2 ~~~
~~~ p1: ok fine
v ----------- v`,
`======= 10:44 ========
because :p2 ~~~
~~~ p1: ok fine
~~~ ~~~
~~~ ~~~
v ----------- v`],
[`> hello
oh hi <`,
`> how are you doing
good <`]
];
for(let test of tests) {
console.log('Input:', test=test.map(x=>x.split('\n')));
console.log('Output:', f(test));
}
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 29 bytes
```
Ỵ€ð¹Ƥp¹ÐƤ}Ṛ⁼"¥Ḣ¥/ÐfḢṖ;¥/ȯ;µ/Y
```
[Try it online!](https://tio.run/##y0rNyan8///h7i2PmtYc3nBo57ElBYd2Hp5wbEntw52zHjXuUTq09OGORYeW6h@ekAZkPNw5zRrIObHe@tBW/cj///9Hq6ur20KAgqGBlYmRApRny1VXV6dQYGilkJHJpYAEMjIVrAqMFICycBWVqcUoSvLy4UrKwAK6CADilgEt1VFAs9kYYTMOs2DWlWdU2sPUJKUmJ5YWp2Koyc9WSMvMSyXBfhMM@wmZDeKjAZgyLMI4XRILAA "Jelly – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 124 bytes
```
def f(S):
x=[]
for y in S:
y=y.split('\n');x+=y;i=0
while(x[i]in y)<1:i+=1
x=x[:i]+y[y.index(x[i]):]
print'\n'.join(x)
```
[Try it online!](https://tio.run/##tVRNc4IwED27v2LHHoSxdURpD1HaH@GRerAlSComDKCQi3/dhg/Fbyljd4YJm33Z9zbZ2UDGnuCD7dahLrraRCeAqWVPAV0RokTGcUKgJS3ZiwKfxVrnk3f0Udq15IhZfWglHvOpltpsqqBSHxuEdS0DWqmV2oRNu9KWPcYdmuYYnajMQch4nOXp/QjGtVTfuprdbrff0WOAuXkMx6B8keAspCjFCh2FnefhuRAOjtWBZ/XVxqtw9lMQSBrlGaY6wJ@ZL2YCyMvCpxoGUBTsM07RgHwZFMuwLOtor1jMSu@lgxXoQVKM/qEWo3@m84aYhioSEToRhHTm@xJ9wecY0oDOYupgETJf30pR6sFu4Lzl8lZ4EXvpl6RVDXeJaydsUrZVmLpjYg6w9CzYbDYYGKTqzX2HkmCAKrpHqCY8gnCxh6zzjZfKMnddXuIh8bAivpJqx5Z48mOH@aLfs1VEzzBiga7qhPr05hn9vdSZf2I72IXtq0LKDvjPN2hycQ@qDpr0oxp/1PdFJlV4@UQsH@zuRK7m6UmC@8N8@ws "Python 2 – Try It Online")
] |
[Question]
[
Task is to output this text:
```
ABCDEFGHIJKLMNOPQRSTUVWXYZA
A 00000000000000000000000 Z
B Y
C 101010101010101010101 X
D W
E V
F 2101210121012101210 U
G T
H S
I R
J 12321012321012321 Q
K P
L O
M 234321012343210 N
N 123432101234321 M
O L
P K
Q 23210123210123210 J
R I
S H
T G
U 1210121012101210121 F
V E
W D
X 010101010101010101010 C
Y B
Z 00000000000000000000000 A
ABCDEFGHIJKLMNOPQRSTUVWXYZA
```
### Rules
* shortest code wins, but you are encouraged to post answers even if your language is among more verbose ones
* trailing newline allowed,
* lowercase letters allowed
[Answer]
# [SOGL 0.8.2](https://github.com/dzaima/SOGL), ~~121~~ 120 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
Z A+p→**1"PļΔķ≠ƨν↕KzøjQ¶°³²y⁹ν⅔E "§768╗@ū℮^‰Y√ψ⅜εrυd┘mZΣlL⅝6׀KTφυZŗ4M7E¤Δ≠⅓∫⁽mΜ‽κuΘ\λ`ω¬ρDDz⅞":e─░χ′⁷‘’«n{;³ZWO≤oZ±WoI}*
```
Explanation:
```
Z push the uppercase alphabet
A+ append "A"
p output in a new line
→* define function "*" with the above
* call the function "*"
1 push 1 (counter)
"...‘ push the middle lines (without the alphabet letters) joined
’«n convert to an array with each item 25 chars long
{ } for each line
;³ put the counter ontop on stack and triplicate it
ZW get the counterth letter of the alphabet
O output in newline
≤ put the current array item ontop of stack
o append
Z±W get the counterth letter of the reversed alphabet
o append
I increase counter
* call the function "*"
```
[Answer]
# [Bubblegum](https://esolangs.org/wiki/Bubblegum), 186 bytes
```
00000000: 7592 d70d c330 0c44 ff6f 0a8e e092 05dc u....0.D.o......
00000010: 2df7 def6 1f24 3263 0429 3e09 2281 7b38 -....$2c.)>.".{8
00000020: 1284 1884 519c a459 6e8a b2aa 9bb6 eb87 ....Q..Yn.......
00000030: 719a 9775 db8f 0081 38f7 470e 84c2 ce8e q..u....8.G.....
00000040: 48c4 756e aec8 8698 fa56 2494 2d48 6df4 H.un.....V$.-Hm.
00000050: 6c8d 9f67 d519 19f5 4dc8 291b 6128 1b50 l..g....M.).a(.P
00000060: 9cc9 f57c edf3 8ea7 d8a3 a4be 0e15 652d ...|..........e-
00000070: 6acd 9eff b8ea 6956 ad41 2357 c34f a85a j.....iV.A#W.O.Z
00000080: 8d96 d6ac d051 56a2 7fb5 fb1e 411b 1618 .....QV.....A...
00000090: a8cf 60a4 2cc7 4459 8659 27f8 fb24 aba6 ..`.,.DY.Y'..$..
000000a0: 58a8 2fc1 4a59 8c4d e46e 95ec 1411 76ea X./.JY.M.n....v.
000000b0: 0b71 d0dd b57b cd77 fe09 .q...{.w..
```
[Try It Online!](https://tio.run/nexus/bubblegum#XZJJb1QxEITv/IoSRIJIpLH9vLQ5IEWKRISEIJeB4YRXBGIRh8Ah/Peh3swkLH2wD8/9varq3pljPUUK2aEn09GWxcA07zFnnDBFB4bhVxN6A66FZeRCvsm@7h0IlgzXZ0IfM8JO57G4uMB4l7GwH86pRaqLAmdr44lrcvpM7suNHhmODOvUwyqPYHND8SEjDi2orhTkWiNG1QSsiCuR7Vf5R8eyerGZT1MK6FXpwPDHi1KbT2ZAfXNog67wXWRvR@X53wxPhtfmGUocKKMpNGbFLCHC@ezp1Ctinx64lOuDhM2JnF1@uWUEMmLTjjwjQ6EZ2DwDfCfNZVsRaRW2BgN8FvmwIl7KqZRH8vrIiGTk1jJmSA2jzwU6CmlaFiZTB8ywATG4vs/jl9zVODsy0qqjNOoYc6KyHzHTRunewi0hcd5@omgowKd978eNnD94I6/k3ZGhZGjPEZ0kdBMsQiwOadaAWe2AtzRko9XDXORqs7/O/2SaySjaJqIpzK81TmOdrUYeLk2mW7kzpZa4Mt7LY7nYyvYh9@SOUcgIWpjfbBa@rO3NdwzPMeUwGiyFIEWaxFt5Ii@2jHQ/nR@3jEqGqcnSRu@oIVW0nhLmuqL/l3BB5EZ@iux2vwE)
[Answer]
# [NO!](https://github.com/ValyrioCode/NO), 34067 bytes
OP asked for verbose. I give you verbose.
I would say the NO! isn't old enough to compete but the length of the code says that it's not competing
As the code is too long for SE, here is a link to the actual code: [actual code](https://tio.run/nexus/python3#7d1BbgIxEETRfU7BTbgB3CTcfzVsoijbiK52e@bNulyW3frlMQj6eDx/n/vj9elz@9yixKPGpMilyqbMp86o0KnSqtSr1qzYrdqu3K/eMOCYsIx4ZkxDrinbmG/OOOictK7w/mtx63jD@P8kRhhhhBE9I7ryuucuRkFBMYL@avhXrbcjpk1iEpPsM8nKYC3PVUceBcUe9NfDrzIUFFvQH4B/8I6c5xXUWqzlMmsZHKCJ/HS0UVBsQH8EfpWhoJhPfwZ@laGgGE9/CP6d96zpfulSbtMut2nbBmUqJx1hFBTD6Y/BrzIUFLPpz8F/8l1te1N1k1CfWfU5axgGs/Dcu4pP@XnZ@pw0DZNh6KWdgmIw/VH4VYaCYi79Wfh96OMmYdNs2vY5GY5JJxgFxVT60/CrDAXFUPrj8KsMBcVM@vPwX/57Xr@ztxZrOUFerApQZxsFxUT6O@BXGQqKgfS3wL9ovf412SQmMcmCXO2JVSceBcU4@pvg1@3OCCOMeF262117B9EeDz3Ke4z0KF/spkf5VEs9yvUoH/IpxlLv29fj@fPcv1/H8QY). I chose a TIO page because I can't be bothered to find anything else.
[Answer]
# PHP, 294 Bytes
```
$d=[0=>[0,23],2=>["01",21],5=>[2101,19],9=>[123210,17],12=>[23432101,15],13=>[12343210,15],16=>[232101,17],20=>[1210,19],23=>[10,21],25=>[0,23]];echo$j=join(range(A,Z)),"A\n";for($i=0;$i<26;$i++)echo$j[$i].str_pad($d[$i]?str_pad("",$d[$i][1],$d[$i][0]):"",25," ",2).$j[-$i-1]."\n";echo$j."A\n";
```
Expanded
```
$d=[
0=>[0,23],
2=>["01",21],
5=>[2101,19],
9=>[123210,17],
12=>[23432101,15],
13=>[12343210,15],
16=>[232101,17],
20=>[1210,19],
23=>[10,21],
25=>[0,23]];
echo$j=join(range(A,Z)),"A\n";
for($i=0;$i<26;$i++)
echo$j[$i].str_pad($d[$i]?str_pad("",$d[$i][1],$d[$i][0]):"",25," ",2).$j[-$i-1]."\n";
echo$j."A\n";
```
] |
[Question]
[
# Goal
As the title suggests, write a radix sort function (either MSB or LSB is fine) that accepts two parameters:
* an array of values of any type (you can assume that they are all of the same type / class, etc.)
* a function (or function pointer, depending on your language) that takes a single parameter of the same type as the objects given in the array and returns the coerced integer key of the object.
Implementation may mutate the array or operate out-of-place, but *must return the sorted array*.
### Tips
* If array indexing in your language is affected by the byte-size of each index, you can assume that the objects referenced in the array are pointers rather than values.
* If the size of an array pointed to in a function parameter cannot be determined in your language, then add another parameter to your radix sort signature, passing the size in bytes of your array, or number of elements in your array, whichever you prefer:
```
void *rsort(void *arr, size_t length, int(*key)(const void *));
```
## Bonus
A bonus reduction of 20% to your score will be given if your implementation [memoizes](https://en.wikipedia.org/wiki/Memoization) the keys of the objects in the array so that the function provided only needs to be called once for each object in the array.
## Example Usage (and test-case)
Assuming an answer was provided in JavaScript, a test-case might look something like this:
```
/* note that this implementation will not be acceptable as a submission -
* it is NOT a true radix sort
*/
function myFakeRadixSort(array, key) {
return array.sort(function(a, b) {
return key(a) - key(b);
});
}
/* this will be used as an example key function -
* you will not need to implement this
*/
function complexity(obj) {
return JSON.stringify(obj).length;
}
var tree = {
a: {
b: {
c: "a string",
d: 12
},
e: ["an", "array"]
},
f: true,
g: {
h: null,
i: {},
j: {
k: 500
}
}
};
/* another example key function
*/
function index(obj) {
return JSON.stringify(tree).indexOf(JSON.stringify(obj));
}
var data = [];
/* this is a hack to traverse the object */
JSON.stringify(tree, function(key, value) {
data.push(value);
return value;
});
document.write(`<h2>Sorted by "complexity"</h2>`);
document.write(`<pre>${myFakeRadixSort(data, complexity).map(o=>JSON.stringify(o)).join`\n`}</pre>`);
document.write(`<h2>Sorted by "index"</h2>`);
document.write(`<pre>${myFakeRadixSort(data, index).map(o=>JSON.stringify(o)).join`\n`}</pre>`);
```
## tl;dr
Write a radix sort with this signature, or as close as possible to this signature:
```
void *rsort(void *arr, int(*key)(const void *));
```
## Leaderboards
```
var QUESTION_ID=71693,OVERRIDE_USER=42091;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&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(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.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(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+|\d*\.\d+|\d+\.\d*)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;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="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <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><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><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>
```
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
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 leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
**Shortest code in bytes wins!**
[Answer]
## Haskell, ~~111~~ 89 bytes \* 0.8 = 71.2
```
f%a=fst<$>iterate(\x->(even#x)++(odd#x))[(x,f x)|x<-a]!!64
f#x=[(i,j`div`2)|(i,j)<-x,f j]
```
Usage example (sort on the sum of the lists): `sum % [[1,2,3,4], [2,3,4,5], [1], [1,4,8], [9], [0]]` -> `[[0],[1],[9],[1,2,3,4],[1,4,8],[2,3,4,5]]`.
Assuming the given functions maps to non-negative 64-bit integers.
This implements binary radix sort.
How it works:
```
[(x,f x)|x<-a] -- map each element x of the input list to a pair
-- (x,f x), so the given function f is used only once
iterate (...) (...) !! 64 -- repeatedly apply one step of the radix sort and
-- take the 64th iteration
fst<$> -- remove the second element of the pair, i.e.
-- restore the original element
-- one step of the radix sort
\x->(even#x)++(odd#x) -- partition the list in pairs with even and
-- odd second elements and divide the second
-- element of the pairs by 2. Re-concatenate
[(i,j`div`2)|(i,j)<-x,f j] -- helper function: filter pairs where the second
-- element j satisfy predicate f. Adjust j.
```
Further calling examples:
```
length % ["Hello","World!","Golf"]
-> ["Golf","Hello","World!"]
(fromEnum.last) % ["Strings","sorted","on","last","character"]
-> ["sorted","on","character","Strings","last"]
maximum % [[1,2,3,4], [2,5,4], [5,5], [4], [6,2], [2,3]]
-> [[2,3],[1,2,3,4],[4],[2,5,4],[5,5],[6,2]]
```
[Answer]
## ES6, 113 bytes - 20% = 90.4
```
(a,g)=>(s=(a,i)=>i?s(a.filter(x=>~x[1]&i).concat(a.filter(x=>x[1]&i)),i<<1):a)(a.map(x=>[x,g(x)]),1).map(x=>x[0])
```
Uses 2 as the radix. Ungolfed:
```
function rsort(array, key) {
array = array.map(value => [value, key(value)]);
// bit becomes zero when the bit falls off the left end
for (bit = 1; bit; bit <<= 1) {
zero = array.filter(pair => !(pair[1] & bit));
one = array.filter(pair => pair[1] & bit);
array = zero.concat(one);
}
return array.map(value => value[0]);
}
```
Test cases:
```
f=(a,g)=>(s=(a,i)=>i?s(a.filter(x=>~x[1]&i).concat(a.filter(x=>x[1]&i)),i<<1):a)(a.map(x=>[x,g(x)]),1).map(x=>x[0]);
/* example key function */
function complexity(obj) {
return JSON.stringify(obj).length;
}
var tree = {
a: {
b: {
c: "a string",
d: 12
},
e: ["an", "array"]
},
f: true,
g: {
h: null,
i: {},
j: {
k: 500
}
}
};
/* another example key function
*/
function index(obj) {
return JSON.stringify(tree).indexOf(JSON.stringify(obj));
}
var data = [];
/* this is a hack to traverse the object */
JSON.stringify(tree, function(key, value) {
data.push(value);
return value;
});
document.write(`<h2>Sorted by "complexity"</h2>`);
document.write(`<pre>${f(data, complexity).map(o=>JSON.stringify(o)).join`\n`}</pre>`);
document.write(`<h2>Sorted by "index"</h2>`);
document.write(`<pre>${f(data, index).map(o=>JSON.stringify(o)).join`\n`}</pre>`);
```
[Answer]
## Pyth, 6 bytes - 20% = 4.8
```
s.gykQ
```
This uses radix sort with base 2^64. Since all keys will be non-long positive integers, they are one digit long in base 2^64. We use `.g` to bucket the numbers, and `s` to flatten the resulting array. Calls to `y` are implicitly memoized.
Define the function `y` with L, which is a `lambda b`. For example:
```
Lab5 ## y = lambda b: abs(b-5)
s.gykQ
```
Less cheaty is this decimal LSB radix sort at **15 bytes - 20% = 12**:
```
us.ge/yk^THGyTQ
```
Which takes the last twenty decimal digits, plenty for 64-bit numbers.
Try it [here](http://pyth.herokuapp.com/?code=L.x%2Fb%5Ce+ssM%60b++++++%22try+number+of+%27e%27s+in+b%3B+except+digitsum%22%0As.gykQ&test_suite=1&test_suite_input=%5B%27Whereas%27%2C+%27recognition%27%2C+%27of%27%2C+%27the%27%2C+%27inherent%27%2C+%27dignity%27%2C+%27and%27%2C+%27of%27%2C+%27the%27%2C+%27equal%27%2C+%27and%27%2C+%27inalienable%27%2C+%27rights%27%2C+%27of%27%2C+%27all%27%2C+%27members%27%2C+%27of%27%2C+%27the%27%2C+%27human%27%2C+%27family%27%2C+%27is%27%2C+%27the%27%2C+%27foundation%27%2C+%27of%27%2C+%27freedom%2C%27%2C+%27justice%27%2C+%27and%27%2C+%27peace%27%2C+%27in%27%2C+%27the%27%2C+%27world%2C%27%5D%0A%5B314%2C159%2C265%2C358%2C979%2C323%5D&debug=0).
] |
[Question]
[
**This question already has answers here**:
[Write a program which performs brute force letter combination until the word "password" is found](/questions/12615/write-a-program-which-performs-brute-force-letter-combination-until-the-word-pa)
(16 answers)
Closed 8 years ago.
So, like the title says, today you are going to guess my password (sort of). You need to make a big long list of every possible password I might be using on my 4 digit online vault.
**Specifications:**
* It could contain any 26 letters of the alphabet in UPPER CASE.
* It could contain any numbers 0-9.
* So, basically, each digit has 36 different possibilities.
* There are four digits.
* Repeat characters are allowed! (Hint: Sample space is 1,679,616 or
36^4)
**Program Requirements/Rules:**
* Program must output all possible answers to a text file or to the console, line by line. (One answer per line)
* You may not make use of any premade tools for this (Idk if any exist, but just in case)
* It must generate all 36^4 possible answers
Remember, this is a Code-golf. So shortest answer in bytes wins. Please use the standard title format of `##Language Name, Byte Size`. Even if there is a winner, feel free to post your answer. (It's always fun to see the different solutions in different languages).
**Edit:** *Not a duplicate of sugested, mines has different context, and different paremeters. (I require numbers, duplicate characters, and only UPPERCASE)*
[Answer]
# Pyth - 8 bytes
```
^+jkUTG4
```
[Try smaller password length online here](http://pyth.herokuapp.com/?code=%5E%2BjkUTG2&debug=0).
[Answer]
## Haskell, 38 Bytes
```
mapM(\a->['A'..'Z']++['0'..'9'])"abcd"
```
yeah, it's not gonna beat Pyth. Oh well...
[Answer]
# Ruby, ~~64~~ 53 bytes
```
[*'A'..'Z',*'0'..'9'].repeated_permutation(4){|a|p a}
```
Probably golfable further, I'm not that good at Ruby.
] |
[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/64611/edit)
Let's say I have a condition expression `x` and that I want to check if it is TRUE or FALSE depending on the value of a boolean `y`:
```
y ? x : !x
```
Is there a way to express it without repeating `x` expression? Something like how we can get a number or its opposite depending on a bool, without repeating the number in the expression:
```
number * (opposite ? -1 : 1)
```
Example, note the repetition of `date.hour < 12` that I want to avoid:
```
tellTheThruth = FALSE; // or TRUE
if (tellTheThruth && date.hour < 12 || !tellTheThruth && !(date.hour < 12) {
print "It's AM"
} else {
print "It's PM"
}
```
Is it possible in all common languages (I was thinking in Javascript and I can't find a solution)? If not, is there some language in which you can?
[Answer]
for two booleans x and y, `y ? x : !x` can be rewritten as `y ^ !x` (y XOR NOT x) or similar in most languages.
[Answer]
## Haskell
```
import Data.Bool.Extras
bool=<<not
```
`bool` from `Data.Bool.Extras` is similar to the `?` operator in other languages. It takes 3 arguments, a False case, a True case and a boolean to decide which one to use. `=<<` works here in function context ( i.e. `(f=<<g) x` is `f (g x) x`), so we can use it as `(bool=<<not) <x> <y>` which is `bool (not <x>) <x> <y>`.
Example: `(bool=<<not) True False` -> `False`.
] |
[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/49002/edit)
# Definitions:
I define a "true antiquine" as follows:
>
> A true antiquine is a non-empty computer program of length `n` which takes no input and produces a copy of every valid program of length `n` in the same language, except the original program.
>
>
>
I define a "modified antiquine" as follows:
>
> A modified antiquine is a non-empty computer program of length `n` which takes no input and produces a copy of every valid ASCII (0-127/7-Bit ASCII, specifically) string of length `n`, except the original program.
>
>
>
Here's what I mean when I say "produces":
>
> A program is said to produce a string if it, were it allowed to run for an arbitrary finite period of time, would print and/or save and/or display a string that contains the string to be produced. In other words, the output must only contain the produced string as a substring. Inversely, any string that is a substring of the output is considered produced, and conversely, any string which does not contain a substring has not produced that substring.
>
>
>
---
# Problem:
Write either a true antiquine or modified antiquine. The program doesn't need to finish in any reasonable amount of time, but has to finish eventually.
The program must be at least 20 characters long. If writing a true antiquine, there must be at least two other valid programs of the same length in the same language as that the program is written in.
If writing a "modified antiquine", the character length restriction is lifted, but of course, a bigger score penalty is received.
---
# Scoring:
The lowest score wins. The formula for scoring programs is as follows:
**(Bytes of Code) [ \* 10 if a modified antiquine ]**
[Answer]
# CJam, 2400
```
'¡G42#{(_128b:co0c24*o}h
```
This takes advantage of what seems to be yet another loophole in the question. My code contains the character `¡` (codepoint 161 in Unicode or ISO-8559-1) to avoid checking if the output may produce the original source codes).
Also, after every program with 24 or less bytes, 24 NUL bytes are printed to avoid generating the original source code as part of two outputs and to make sure all strings starting with a run of NUL characters are generated.
# How it works
```
'¡ " Push a non-ASCII character. ";
G42# " Push I := 16 ** 42 = 128 ** 24. ";
{ " Do: ";
(_ " Decrement I and push a copy. ";
128b:co " Get the associated ASCII string and print it. ";
0c24*o " Print 24 NUL bytes. ";
}h " While I is positive, repeat. ";
```
[Answer]
# C, 392 \* 10 = 3920
Nobody's submitted a true answer yet, so I'll offer up a baseline solution:
```
char*s="char*s=%c%s%c;n;main(){char b[999],t[392]={0};sprintf(b,s,34,s,34);while(1){n=0;while(n<392&&t[n]==127)t[n++]=0;if(n==392)break;t[n]++;if(strcmp(b,t)){for(n=0;n<392;n++)putchar(t[n]);putchar(10);}}}";n;main(){char b[999],t[392]={0};sprintf(b,s,34,s,34);while(1){n=0;while(n<392&&t[n]==127)t[n++]=0;if(n==392)break;t[n]++;if(strcmp(b,t)){for(n=0;n<392;n++)putchar(t[n]);putchar(10);}}}
```
**Testing is not recommended outside of a debugging environment--this program will not terminate on its own for the foreseeable future.** Prints every combination of 392 characters that *isn't* the source, separated by newlines. Because the source contains no newlines, the full source will never appear in the output. I've run it through most of the tests I can think of, and it seems to work, but this is of course difficult to verify. This program is essentially a modified quine--rather than printing the source out, it saves it in the string `b`. It generates a unique string, checks it against `b`, and outputs it if it is different. This could probably be shortened a bit.
] |
[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/7181/edit)
A favorite puzzle of mine. Not massively difficult but a tad interesting.
**The Objective**
Using a low level language (C/C++/similar level) - create a doubly linked list of elements that only stores a single pointer instead of storing both a previous and next element pointer as you normally would.
You must be able to find each element in your linked list, starting from either the first element you created, or the most recently created element.
You must use `malloc(sizeof(*node))` or similar to store each element (the addresses are likely to be non-sequential as a result)
**The Restrictions**
* The data type you use to store your value must be the length of a function pointer (No using long values to store 2 pointer addresses one after another)
* You may not use any external libraries (only the standard libc methods are permitted if you're using C/C++, apply the spirit of this rule to other languages)
* You may not store any additional metadata elsewhere (or in the list elements themselves) to solve this. The list element may only contain two fields - the 'data' value and the value you will use to find the previous and next elements. It may look something like:
`struct node
{
int myValue;
struct node* prevAndNextNode;
}`
**Golf or Challenge?**
You can either find the most elegant/interesting solution, or the shortest. Take your pick!
Have fun ;)
[Answer]
This is an [xor linked list](http://en.wikipedia.org/wiki/XOR_linked_list):
```
struct node {
int myValue;
uintptr_t xor_prev_and_next;
node *next(node *prev) {
return (node*)((uintptr_t)prev ^ xor_prev_and_next);
}
node *prev(node *next) {
return (node*)((uintptr_t)next ^ xor_prev_and_next);
}
}
struct list {
node *first;
node *last;
int sum_forwards() {
int sum = 0;
node *prev = NULL;
node *curr = first;
while (curr) {
sum += curr->myValue;
prev, curr = curr, curr->next(prev);
}
return sum;
}
}
```
[Answer]
# EDIT
### Problem Definition
* For a given node, find the next node (null if tail)
* For a given node, find the previous node (null if head)
* Return a node at a specified offset from the start of the list (null if out of bounds)
* Return a node at a specified offset from the end of the list (null if out of bounds)
The constraints have been revised by the OP, and include restricting the nodes as well as external structures from storing any metadata. My initial implementation of a Circular Linked List did not meet this criteria since it required knowing the head node with a flag value.
I present now a clever workaround:
# A Circular Linked List with Forced Node Address Parity
Note that lately I am a C# programmer, but I will try to do this C-style as possible.
### The List Node Structure
Nothing fancy here:
```
struct ListNode
{
ListNode *next;
int value;
};
```
### Adding Nodes with Even Addresses Only
Since this implementation still requires that we be able to find the start of the list, we can use the LSB of the `next` pointer as a flag. If the last bit of the `next` pointer is 1, it means we are at the end of the list. A few helper functions:
```
bool isPtrOdd(void * addr)
{
if((unsigned int) addr & 1)
return 1;
return 0;
}
ListNode * GetNodeAddr(ListNode * node)
{
if(isPtrOdd(node))
return node - 1;
return node;
}
```
The only special considerations are that we must ensure that nodes are allocated only on even addresses. There are several ways of doing this, but I will show a basic one which allocates an extra byte for each node:
```
ListNode * NewNode()
{
void * memBlock = malloc(4 + 4 + 1); // 32 bit address, 32 bit value, 1 padding byte
if(isPtrOdd(memBlock)) // if the block started on an odd address
memBlock++; // shift over to an even address
ListNode * newNode = memBlock;
newNode->value = 0;
newNode->next = newNode + 1; // a new node circularly points to itself
return newNode;
}
void AddNode(ListNode * list, ListNode * newNode)
{
while(!isPtrOdd(list->next))
list = list->next; // Get to the end of the list
newNode->next = list->next; // Point the new node to the list head + 1
list->next = newNode;
}
```
### Traversing the List
And using C-style external functions (no classes) we define each of the desired functions:
```
ListNode * NextNode(ListNode &Node)
{
if(isPtrOdd(Node->next))
return 0;
return &(Node->next);
}
ListNode * PrevNode(ListNode &Node)
{
ListNode curNode = Node;
while(&(GetNodeAddr(curNode->next)) != &Node) // We compare addresses instead of values
curNode = GetNodeAddr(curNode->next); // since the == operator is not defined for structs
if(isPtrOdd(curNode->next)) // if the 'previous node' is actually the end of list
return 0;
return &curNode;
}
ListNode * NodeFromStart(ListNode &Node, int offset)
{
// This function returns offset from head node given
// any node in the list
ListNode Head = Node;
while(!isPtrOdd(Head->next)) // Loop completes when tail is found
Head = GetNodeAddr(Head->next);
Head = GetNodeAddr(Head->next); // Move once more and get to head
for(int n=0; n<offset; n++)
{
if(isPtrOdd(Head->next)) // if we reach the end of the list
return 0;
Head = Head->next;
}
return &Head;
}
ListNode * NodeFromEnd(ListNode &Node, int offset)
{
// This function returns offset from tail node given
// any node in the list
ListNode Head = Node;
while(!isPtrOdd(Head->next)) // Loop completes when tail is found
Head = GetNodeAddr(Head->next);
Head = GetNodeAddr(Head->next); // Move once more and get to head
// Determine number of nodes in List
int count = 1;
while(!isPtrOdd(Head->next))
{
Head = GetNodeAddr(Head->next);
count++;
}
if(count<=offset)
return 0;
return NodeFromStart(Head,count - offset);
}
```
] |
[Question]
[
Given some raw HTML, sanitize it by formatting the spaces, as defined below.
## Output rules:
Like [many](https://codegolf.stackexchange.com/search?q=xkcd) challenges, this one is inspired by [XKCD](https://xkcd.com/2109/).
1. First, "untag" all tags with nothing but spaces in them. (`<i>te<b> </b>xt</i>` becomes `<i>te xt</i>`). If a tag has nothing in it (like `<b></b>`, simply delete it and move on.
2. Next, "push" the spaces to the edge. This means that to push spaces at the edge of the tag outside (so `<b><i> test </i></b>` becomes `<b><i> test</i> </b>` after one step).
3. Keep repeating steps 1 and 2 until no new changes happen.
4. Collapse sets of spaces. For example, `<b><i>test</i></b>` should become `<b><i>test</i></b>` .
5. Finally, trim the string (this means remove the spaces at the edges, so " ***a*** " becomes "***a***"). An empty string can be the result.
## Input
The input may be taken as an array of bytes or a string. The only tags will be `<b>`, `<strong>`, `<i>`, `<u>`, and `<em>`, and they may have additional attributes may be in the starting tags (so one starting tag could be `<b data-this-is-an-attribute="true">`. The ending tags, in order, are `</b>`, `</strong>`, `</i>`, `</u>`, and `</em>` and will not have attributes. Closing tags will be in order (so `<b><i></i></b>` works, but `<b><i></b></i>` will never be a test case). There are no newlines in the input.
**Edit: attributes may be in single or double quotes.**
Be sure not to follow any of the rules for the tags, especially the spaces!
```
"<b> <i> </i></b>" -> "<b> </b>" -> " " -> "" (the quotes in this test case are to prevent confusion)
<u> x <em onclick="alert('Hi!')" style="font-size: 50px">kcd </em> comics </u> -> <u>x <em onclick="alert('Hi!')" style="font-size: 50px">kcd</em> comics</u>
<strong>Formatting<i> </i>is <u data-info='test case'>HA RD</u></strong> -> <strong>Formatting is <u data-info='test case'>HA RD</u></strong>
s p a c e s -> s p a c e s
one<i> </i>space -> one space
-> (no changes, as we don't consider )
```
As this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the shortest answer in bytes wins!
Note: you can use any language to do this challenge; it's just inspired by HTML.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~106~~ 97 bytes
```
{`<([a-z]+)[^>]*>( )*</\1>
$2
((^|>)[^<]* ) +([^>]*($|<))
$1$3
^((<[^>]+>)*) | ((<[^>]+>)*)$
$1$3
```
Can definitely be golfed some more.
[Try it online.](https://tio.run/##XVBNTwIxFLz3Vzw3q9suISsaL1peYkKUM1c@pJRCGth2sy0JIv997XYlou/SvJnJzOvUymsjBs0tfV82X0tOp6J/mvfYdIHzHCmwnBezAZL0gVC6OGMg@DwHBj0aJTQ9c8ZIOkgfyYJS3oI9ZDmDM1yvaZQ0DdfoFV8hhOHFCo@eFxpJQAIDXjnf4hpbjkRdi/8iB4QjcFWCNXKv5W6YiL2qPc3G@iZjCTj/uVfDZGON7zt9Us/wdF8dE9zJdXBRJYK0pZYuLIdg53xtzRbfbF0KH5rYXtJ0UBxgLbzoa7Oxw6Q7LYwUTiU4fo3LZNT68OLHJyDEQQUCZKQVOGKNupi6SkhF7szKVS/QPfHn10HZn6AMP7qASxsxdzLqyiP/riKx2pZx/hs)
**Explanation:**
Keep executing the replacements until the result no longer changes:
```
{`
```
Step 1: untag all tags that only contain spaces and remove empty tags:
```
<([a-z]+)[^>]*>( )*</\1>
$2
```
Step 4: collapse sets of spaces to a single space, unless they're inside an attribute:
```
((^|>)[^<]* ) +([^>]*($|<))
$1$3
```
Step 5: 'trim' leading/trailing spaces, ignoring the tags:
```
^((<[^>]+>)*) | ((<[^>]+>)*)$
$1$3
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 86 bytes
```
{`(<[^/>]+>)
$1
(</.*?>)
$1
^ |<[^/>]+></.*?>| $|( )+|(?<=<[^>]*)((["']).*?\3)
$1$2
```
[Try it online!](https://tio.run/##nZDNTsMwEITveYolCsRpVcKPuICzFRKCnnstreq4bmU1saPYkQrk3YPdEASIA8IX78x4v125FlYq1p2Sp3X3tiZ0sUpxOcYEAoguAyA0PR9NMQmcWEE7xL3bQtQSSMYtmdLMRbgcJYQswniZuPj52ndFV11HcwSgEoGm0rXmGAS0QTgAFSVoxQvJ91nIClFbEs/kSZyEYOxLIbJwq5WdGPkqbuHmojqEuOcbhxElAtel5MaJBj3uv7SvsJ5lbK3VDh91XTLrfmc3rC7dtAY2zLKJVFudxVYYC/5wZkSMs/ujmD94Dk0/OM75hQl/gP0ABQYqYMCPjwSYT@1rrcSwpqkYF96AvjpTuanuoL@@q3c "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
{`
```
Repeat the following replacements as many times as necessary.
```
(<[^/>]+>)
$1
```
Move a space after an open tag to before it.
```
(</.*?>)
$1
```
Move a space before a close tag to after it.
```
^ |<[^/>]+></.*?>| $|( )+|(?<=<[^>]*)((["']).*?\3)
$1$2
```
Handle all of the remaining cases:
* `^` Delete leading spaces
* `<[^/>]+></.*?>` Delete empty tags
* `$` Delete trailing spaces
* `( )+|(?<=<[^>]*)((["']).*?\3)` Collapse spaces not inside attributes
] |
[Question]
[
* Let us assume that we have number `X`.
* Let us assume that we have positive integer "components" (`C`) of this `X` number.
* We can add these components together like `C1+C2+...+Cn = X`.
* We have `N` as limit of number of components.
* We have `B` as limit of biggest component
* Distribution: if we have `[8;8;5]` then avg of components is `7`,
distribution is `abs(8-7)+abs(8-7)+abs(5-7) = 4`
* Lowest distribution: `dist([8;8;5])=4 dist([7;7;7])=0` -> lowest
distribution from these sets is `[7;7;7]`
* Component order does not matter.
* Components shall be the same number except one item which can be lower.
Examples
```
X = 17
N = 3
B = 8
```
* Then possible component sets are `[8;8;1]`, `[7;7;3]` and `[6;6;5]`.
* The lowest distribution between the components is in `[6;6;5]`,
that's what we need.
---
```
X = 21
N = 3
B = 8
```
* Possible sets: `[8;8;5]` and `[7;7;7]`.
* Winner is `[7;7;7]`.
---
```
X = 22
N = 3
B = 8
```
* Possible sets: `[8;8;6]` and no more.
* Winner: `[8;8;6]`
---
---
```
X = 25
N = 3
B = 8
```
* Possible sets: - (due to B = 8)
---
I'm looking for the shortest script for this problem written in Javascript.
I have a 10 Line solution.
My solution:
```
const findComponents = (X, B, N) => {
let S = null;
let mainComponent = Math.ceil(X / N);
if (mainComponent <= B){
let otherComponent = X % mainComponent;
S = Array(N - 1).fill(mainComponent);
S.push(otherComponent == 0 ? mainComponent : otherComponent);
}
return S;
}
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~16 10~~ 9 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
÷Ċ¬>¡⁵⁸sẈ
```
A full program that accepts `X N B` and prints a list or errors if no solution is possible.
**[Try it online!](https://tio.run/##ASMA3P9qZWxsef//w7fEisKsPsKh4oG14oG4c@G6iP///zE3/zP/OA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##qyrO@P@/JLW4RENToZorNTkjX0E3T0FJxUHB1k5BiSsrNSenUiG1NE9B/fD2I12H1tgdWvioceujxh3FD3d1qCsA1RnZqRko1NQogPUq5eUrFOfnlJZk5ucppOWX5qUocdVygcxXMDRXMFawgLCNDJHYRkhsUxD7/38A) (Thanks, [Steffan](https://codegolf.stackexchange.com/users/92689/steffan)!)
...if erroring is not acceptable then \$10\$ with `s÷Ċ¥Ẉ«Ƒ⁵ȧƊ` ([TIO](https://tio.run/##ASUA2v9qZWxsef//c8O3xIrCpeG6iMKrxpHigbXIp8aK////MjX/M/84)) prints `0` instead.
### How?
```
÷Ċ¬>¡⁵⁸sẈ - Main Link: integer, X; integer, N
÷ - (X) divided by (N)
Ċ - round up to an integer (let's call this R)
⁵ - set the right argument to the program's third argument = B
¡ - repeat...
> - ...number of times: (R) greater than? (B)
¬ - ...action: logical NOT
i.e. replace R with 0 if R>B (let's call this P)
⁸ - chain's left argument = X
s - (implicit [1,2,...,X]) split into chunks of length (P)
Note: trailing elements are kept e.g. 7s3 -> [[1,2,3],[4,5,6],[7]]
Ẉ - length of each
- implicit print
```
[Answer]
# [Python](https://www.python.org), 53 bytes
```
lambda x,n,b:[y:=b>=(y:=-(-x//n))and y]*~-n+[~-x%y+1]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vweI025ilpSVpuhY3TXMSc5NSEhUqdPJ0kqyiK61sk-xsNYCUroZuhb5-nqZmYl6KQmWsVp1unnZ0nW6FaqW2YSxUs3NBUWZeiUaahqG5jrGOhaYmF0zAyBBdwAhdwBQiADFqwQIIDQA)
Port of my JS answer (which is a port of Jonathan Allan's Jelly answer). Errors for no possible solution.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 61 bytes
```
(x,n,b)=>(a=[...Array(--n).fill(y=(x+n)/-~n|0),x-n*y],y>b||a)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70kLz8ldcGiNNulpSVpuhY3bTUqdPJ0kjRt7TQSbaP19PQci4oSKzV0dfM09dIyc3I0KoEqtPM09XXr8moMNHUqdPO0KmN1Ku2SamoSNaGGRCfn5xXn56Tq5eSna6RpGJrrGOtYaGpyoQobGWIXNsIubAoRhlixYAGEBgA)
Similar to Jonathan Allan's answer.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `R`, ~~22~~ ~~12~~ 9 bytes
```
/⌈~≥[¹ẇvL
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBUFIiLCIiLCIv4oyIfuKJpVvCueG6h3ZMIiwiIiwiMywgMTcsIDhcbjMsIDIxLCA4XG4zLCAyMiwgOFxuMywgMjUsIDgiXQ==)
*-10 bytes by porting Jonathan Allan's answer*
Outputs a positive integer for no solution.
If that's not allowed:
# [Vyxal](https://github.com/Vyxal/Vyxal) `R`, 10 bytes
```
/⌈~<ßQ¹ẇvL
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBUFIiLCIiLCIv4oyIfjzDn1HCueG6h3ZMIiwiIiwiMywgMTcsIDhcbjMsIDIxLCA4XG4zLCAyMiwgOFxuMywgMjUsIDgiXQ==)
For no solution, produces no output.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÅœIùʒ@P}ʒ¦Ë}θ
```
Inputs in the same order as the challenge description: \$X,N,B\$.
[Try it online](https://tio.run/##ASUA2v9vc2FiaWX//8OFxZNJw7nKkkBQfcqSwqbDi33OuP//MjEKMwo4) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWVCWOj/w61HJ0cc3nlqUmSxQ0DtqUmHlh3urj2347/O/@hoQ3MdYx2LWJ1oI0MYwwjGMIUyTEx0THQMjYAsQ4hcLAA).
**Explanation:**
```
Ŝ # Get all lists of positive integers that sum to the first (implicit) input `X`
Iù # Only keep the lists with a length equal to the second input `N`
ʒ # Filter this list by:
@ # Check if the third (implicit) input `B` is >= the current value
P # Check that it's truthy for all values in the list
}ʒ # After the filter: filter again:
¦ # Remove the first value of the list
Ë # Check if all other values are the same
}θ # After the filter: pop and keep the last list
# (which is output implicitly as result)
```
] |
[Question]
[
Pipe a short stream to the following Java program run with accompanying command line options, such that it prints `true`.
```
class Code implements java.io.Serializable {
private static final long serialVersionUID = 0L;
private static long count;
@Override public int hashCode() {
++count;
return super.hashCode();
}
public static void main(String[] args) throws Throwable {
new java.io.ObjectInputStream(System.in).readObject();
System.err.println(count != (int)count);
}
}
java '-Djdk.serialFilter=maxarray=100000;maxdepth=16;maxrefs=500;Code;java.util.HashSet;java.util.Map$Entry;!*' Code
```
**Rules**
* Shortest stream in bytes wins.
* The program above must print `true`.
* No fiddling with the command line - no aliasing, no running a weird shell, no putting nonsense in classpath, etc. (It does require the quotes. The `Map$Entry` bit is indeed weird.)
* In case of issue, run on Oracle JDK13 current update at time of posting.
* Tie breaker: size of stream in bytes when compressed with `gzip --best` (on my machine, if that's variable).
Probably post the source code to generate the stream, rather than some bytes.
[Answer]
1087 bytes
1065 bytes
Apparently the JDK's maxdepth limit is kinda broken...
```
static Object payload() throws Exception {
int layers = 30;
int width = 2;
int codes = 7;
int extra = 8;
List<Set<Object>> sets = new ArrayList<>();
sets.add(new HashSet<>());
for (int i = 1; i < layers; i++) {
Set<Object> s = new HashSet<>();
sets.add(s);
for (int j = i - 1; j >= i - width - 1 && j >= 0; j--) {
sets.get(j).add(s);
}
}
for (int i = 0; i < codes; i++) {
sets.get(sets.size() - 1).add(new Code());
}
// special HashSet at the root to circumvent maxdepth limitation. By including a couple deeply
// nested HashSets here, they will be replaced by references when they're used inside `sets`.
// Using a LinkedHashSet to guarantee order of serialization.
LinkedHashSet<Object> linkedRoot = new LinkedHashSet<>();
linkedRoot.add(sets.get(28));
linkedRoot.add(sets.get(14));
linkedRoot.add(sets.get(0));
// shaving off some more bytes by storing multiple copies of the same set at the top level
for (int i = 0; i < extra; i ++) {
sets.get(0).add("foo" + i);
linkedRoot.add(sets.get(0));
sets.get(0).remove("foo" + i);
}
// transplant the contents of the LinkedHashSet into the HashSet
Set<Object> root = new HashSet<>();
Field mapField = HashSet.class.getDeclaredField("map");
mapField.setAccessible(true);
mapField.set(root, mapField.get(linkedRoot));
return root;
}
```
Base64-encoded data:
```
rO0ABXNyABFqYXZhLnV0aWwuSGFzaFNldLpEhZWWuLc0AwAAeHB3DAAAABA/QAAAAAAAC3NxAH4AAHcMAAAAED9AAAAAAAABc3EAfgAAdwwAAAAQP0AAAAAAAAdzcgAEQ29kZQAAAAAAAAAAAgAAeHBzcQB+AARzcQB+AARzcQB+AARzcQB+AARzcQB+AARzcQB+AAR4eHNxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAAJxAH4AAnEAfgADeHEAfgACcQB+AAN4cQB+ABlxAH4AAnhxAH4AGHEAfgAZeHEAfgAXcQB+ABh4cQB+ABZxAH4AF3hxAH4AFXEAfgAWeHEAfgAUcQB+ABV4cQB+ABNxAH4AFHhxAH4AEnEAfgATeHEAfgARcQB+ABJ4cQB+ABBxAH4AEXhxAH4AD3EAfgAQeHEAfgAOcQB+AA94c3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3NxAH4AAHcMAAAAED9AAAAAAAADc3EAfgAAdwwAAAAQP0AAAAAAAANzcQB+AAB3DAAAABA/QAAAAAAAA3EAfgAMcQB+AA1xAH4ADnhxAH4ADHEAfgANeHEAfgAncQB+AAx4cQB+ACZxAH4AJ3hxAH4AJXEAfgAmeHEAfgAkcQB+ACV4cQB+ACNxAH4AJHhxAH4AInEAfgAjeHEAfgAhcQB+ACJ4cQB+ACBxAH4AIXhxAH4AH3EAfgAgeHEAfgAecQB+AB94cQB+AB1xAH4AHnhxAH4AHHEAfgAdeHEAfgAacQB+ABpxAH4AGnEAfgAacQB+ABpxAH4AGnEAfgAacQB+ABp4
```
[Answer]
This one’s 1207 bytes and performs 3910245742 hashes.
```
private fun veryHashySet(): Set<Any> {
val codes = listOf(Code(), Code())
val sets = mutableListOf<Set<Any>>()
for (i in 0 until 16) {
val limit = if (i == 15) 3 else 2
for (j in 0 until limit) {
val set = HashSet<Any>()
for (k in 0 until 4) {
when {
k < sets.size -> set.add(sets[sets.size - 1 - k])
k < codes.size -> set.add(codes[k])
}
}
sets += set
}
}
return sets.last()
}
```
Data:
```
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
```
] |
[Question]
[
**This question already has answers here**:
[The Coin Problem](/questions/57146/the-coin-problem)
(6 answers)
Closed 4 years ago.
You are starting up a cryptocurrency exchange website which supports conversion from USD to two currencies, foo-coin and bar-coin. Write a program that takes the exchange rate for each coin to USD as arguments and outputs the maximum value of USD that cannot be completely divided into the two currencies (assuming these crypto-coins can only be purchased as full coins):
e.g.
If the two exchange rates are $23 and $18, then 41 dollars could be split into 1 foo-coin and 1 bar-coin, but there is no way to completely split 42 dollars between the two coins. The output of the program for these two values is 373, as that is the largest dollar amount that CANNOT be divided into whole values of foo-coin and bar-coin.
Winner is the program with the fewest characters.
edit:
You may assume the GCD of the two rates is 1
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 3 bytes
```
<P<
```
[Try it online!](https://tio.run/##yy9OTMpM/f/fJsDm//9oQwsdI@NYAA "05AB1E – Try It Online")
This is of course only assuming that the greatest common denominator of the inputs (exchange rates) is 1, because otherwise this number is not well-defined.
**Explanation:**
The number we want to compute is called the [Frobenius Number](http://mathworld.wolfram.com/FrobeniusNumber.html) and can be calculated with the formula \$\operatorname{Frob}(a,b) = (a-1)(b-1) - 1\$.
```
< | Subtract 1 from each input
P | Take their product
< | Subtract 1
```
[Answer]
# [Swift](https://developer.apple.com/swift/), 42 bytes
```
func d(f:Int,b:Int)->Int{return f*b-(f+b)}
```
[Try it online!](https://tio.run/##Ky7PTCsx@f8/rTQvWSFFI83KM69EJwlEauraAcnqotSS0qI8hTStJF2NNO0kzdr//wE "Swift – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 bytes
```
t*thQte
```
[Try it online!](https://tio.run/##K6gsyfj/v0SrJCOwJPX//2gjYx0FQ4tYAA "Pyth – Try It Online\"Online")
As @Wisław pointed out, this is simply the Frobenius Number. Also uses `(a-1)(b-1)-1`, as the alternate `ab-a-b` is a bit longer.
## How it works
```
*thQ - Multiply the first number minus one
te - By the second number (the Q is implicit) minus one
t - Minus one
```
] |
[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/172809/edit)
Awhile back I encountered a simple programming puzzle to determine whether a string was a [pangram](https://en.wikipedia.org/wiki/Pangram), or a perfect pangram. (Although it's worth noting that this particular challenge gave a different meaning than the standard definition of a "perfect pangram," to mean any sentence where every letter appears *n* times for some positive *n*). And it was a fun challenge. But recently it got me wondering whether it would be possible to solve this challenge purely with regular expressions. If it is, I expect it will be a pretty gnarly regex. But I'm not even sure it is possible.
Still, if anyone is able to do it, it would be the folks here at Code Golf. So here's the challenge:
Write a regular expression which can determine whether or not a given string is a pangram. You can assume that all non-alpha characters have already been stripped out (or don't, if you really want to challenge yourself), and that everything has been transformed into lowercase.
Bonus challenge: write another regular expression to determine whether the given string is a "perfect pangram" by the definition given above.
Examples of an ordinary pangram:
>
> thequickbrownfoxjumpsoverthelazydog
>
>
>
Example of perfect pangrams:
>
> abcdefghijklmnopqrstuvwxyz
>
>
> jocknymphswaqfdrugvexblitz
>
>
> squdgykilpjobzarfnthcwmvexhmfjordwaltzcinqbuskpyxveg
>
>
>
I'm not really sure if this is even possible just with regex alone. If you find that it is, kudos!
[Answer]
Assuming you're using a flavor of regex that include look-aheads, detecting a pangram is straightforward, but tedious. Using Python syntax:
`r"(?=.*a)(?=.*b)(?=.*c)(?=.*d)(?=.*e)(?=.*f)(?=.*g)(?=.*h)(?=.*i)(?=.*j)(?=.*k)(?=.*l)(?=.*m)(?=.*n)(?=.*o)(?=.*p)(?=.*q)(?=.*r)(?=.*s)(?=.*t)(?=.*u)(?=.*v)(?=.*w)(?=.*x)(?=.*y)(?=.*z).*"`
<https://regex101.com/r/Z7NjEQ/2>
The `(?=.*a)` block tests if what follows after that point matches `.*a`; another way to say that is, is this expression followed by any characters and then an `a`, or just, does this include an `a`? Then repeat that check for every letter of the alphabet.
Without lookaheads, it's still possible, but even more tedious, because you have to account for every possible ordering of the alphabet. If you were limited to the letters `abc`, here's what it might look like:
`r".*(a.*b.*c|a.*c.*b|b.*a.*c|b.*c.*a|c.*a.*b|c.*b.*a).*"`
<https://regex101.com/r/OnXQe7/1/>
This checks for an `a`, any set of characters, a `b`, any set of characters, then a `c`, OR an `a`, any set of characters, a `c`, any set of characters, then a `b`, OR...you get the idea.
You could use the same approach to check for the standard meaning of perfect pangram (every character exactly once), but not the modified version used here.
[Answer]
**Regexp: 45 43 20 19 18 bytes**
```
(?!.*(.).*\1).{26}
```
Assuming the input is [a-z] (lowercase, only alphabets a to z, spaces etc removed)
A byte saved, thanks to Neil
] |
[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/172638/edit).
Closed 5 years ago.
[Improve this question](/posts/172638/edit)
# Game
In this challenge you will play a made-up turn-based game.
The game is made up of the following elements:
* A 8x8 grid with each spot containing nothing (space), a robot (`*`), a wall (`#`), or HP (`@`)
* A public stack
---
# Robots
In this challenge, you will be playing as a robot. Each robot has health (starts at 10HP and cannot exceed it), and a register called `D` for data storage purposes, and `C` for execution (both initially 0). Each robot also has a program attached to it and a program can contain the following instructions (case-insensitive):
* `P`: Pushes the character in memory lying at position `D` (where `D` is the D register value) onto the public stack (All robots share the same stack, hence "public").
* `G`: Pops 2 values from the stack, modulo the ASCII codes by 2, NANDs them, pushes the result
* `D`: Sets the `D` register (NOT the value in memory residing at `D`) to a popped value from the public stack
* `M`: Sets the character in memory lying at position `D` to a popped value's ASCII
* `K`: Sets `C` to `D`, and `D` to 0
* `Y`: Performs a "physical" action with the robot according to:
+ `V = 32` move right on grid unless blocked by wall
+ `V = 33` move up on grid unless blocked by wall
+ `V = 34` move left on grid unless blocked by wall
+ `V = 35` move down on grid unless blocked by wall
+ `V = 36` damage all robots next to you (horizontally or vertically or diagonally or on the same grid spot) by 1HP, killing them if their HP reaches 0, but sacrifice 1HP of your own (this may kill your robot)
+ `V = 37` heal yourself by 1HP for each robot next to you, but also heal them by 2HP
+ `V = 38` break any walls around you but get damaged 1HP for each wall
+ Anything else: Your robot dies.Where `V` = the ASCII code of the value at memory position `D`
* `I`: Pop 2 values, x and y, from the stack, and push whatever is on the grid at the x and y coordinates (pushes the character as specified at the top of this post)
* `S`: Starts a code block
* `E`: Ends a code block and pushes a special "code" value onto the stack. Any robot to try to pop this value will end up executing the code in the block, and the value will be removed from the stack.
* Anything else: Your robot dies.
Memory is initialized at the beginning of the game and the code is inserted at the beginning. Code and data share the same memory. If a robot dies, it's grid spot is replaced with HP which can be picked up by moving over it and heals you 4HP
---
## Execution
Each time it is your turn, the instruction at the position of memory `C` is executed according to the table above before incrementing register `C`.
---
# Submission
Please use this template when posting:
```
#<name of bot>
…
<your bot code>
…
```
Standard loopholes apply, and the last robot standing wins!
[Answer]
# Gun Factory
Why don't you go shoot yourself in the foot?
```
S0EK
```
Constantly pushes a special execution character containing `0`, which isn't executable, thus (hopefully) making bots kill themselves.
[Answer]
# Priest
Let's heal up!
```
PDYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYS%EYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
```
Self-explanatory. It will heal itself constantly for over 40 thousand turns. Avoids the public stack like the plague it is because of the [Gun Factory](https://codegolf.stackexchange.com/a/172646/74965).
[Answer]
# Virus
Spreads code which spreads code which spreads code which spreads code which kills
```
SSSSSSSSSSSSSSSSS0EGKEGKEGKEGKEGKEGKEGKEGKEGKEGKEGKEGKEGKEGKEGKEGKEK
```
[Gun Factory](https://codegolf.stackexchange.com/a/172646/74965) is immune though. And it takes a long time to start up obviously.
[Answer]
# K
```
K
```
Bot does nothing but sit there and lets everyone else kill themselves (k? k.)
As it never interacts with the public stack it is never in danger of executing arbitrary code (and everyone knows how dangerous arbitrary code execution is). Could still be damaged by other bots getting close and executing `Y(36)`, but that command uses the stack, so it will be unreliable.
[Answer]
# FreeKills
Damages without getting damaged! (but takes a long time..)
```
S$EPPPGGDYPDS00000000000000000000000%EYPPGDK
```
[Answer]
# Stack Simplification Unit
Collapse the stack, two pops and one push at a time.
```
GK
```
Probably dies to the pesky [Gun Factory](https://codegolf.stackexchange.com/a/172646/74965) quite quickly, unfortunately.
[Answer]
# Duplicity
Take from some, give to others.
```
S EPPGPGDYYYPDYYYPDYYYPDYYYPPGDK$0%0"1
```
Attacks bots to the right, heals bots to the left. Very vulnerable to stack pollution, which is rampant.
Code explanation:
```
S E - define (32, move right) at 1
PPGPGD - set reg D to 1
YYY - go right thrice
$ - define (36, attack) at 32
PD - set reg D to 32
YYY - attack thrice
" - define (34, move left) at 36
PD - set reg D to 36
YYY - move left thrice
% - define (37, heal) at 34
PD - set reg D to 34
YYY - heal thrice
1 - define (49) at 37
PPGD - set reg D to 0
K - set reg C to 0
```
] |
[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/135852/edit).
Closed 6 years ago.
[Improve this question](/posts/135852/edit)
In the physical world, invisible ink usually becomes invisible when it dries, and is then is readable if it is exposed to heat or chemicals of some kind. The invisible ink in this challenge will be readable when exposed to highlighting.
Create a full program or function that takes in text from the console (using a prompt) and outputs it the console so it cannot be seen unless highlighted (selected, as you would with a mouse).
[](https://i.stack.imgur.com/LoWYQ.png)
[](https://i.stack.imgur.com/vufZz.png)
## Notes:
* Assume that the console is a solid color (black, white, green, etc.).
This is code golf, so the shortest answer in bytes wins.
[Answer]
# JavaScript (ES6), ~~44~~ 42 bytes
Tested in Chrome & Firefox.
```
s=>console.log("%c"+s,"color:transparent")
```
---
## Try it
Open your browser's console.
```
(
s=>console.log("%c"+s,"color:transparent")
)("Invisible Text!")
```
---
# [Japt](https://github.com/ETHproductions/japt/), ~~21~~ 20 bytes
Will post this separately when/if the challenge is reopened
```
Ol"%c"+U`¬l:ÉspÂÁt
```
[Test it](http://ethproductions.github.io/japt/?v=1.4.5&code=T2wiJWMiK1VgrGyOOsmYc3DCwXQ=&input=IkludmlzaWJsZSBUZXh0Ig==)
[Answer]
## [Magneson](https://github.com/UnderMybrella/Magneson), 102 bytes
[](https://i.stack.imgur.com/dp1Vu.png)
(source: [googleapis.com](https://storage.googleapis.com/brella-archives/Code%20Golf/Magneson/always_invisible_ink_visible.png))
(Note that the above is an enlarged version of the program, and the action source can be found [here](https://web.archive.org/web/20210507031700/https://storage.googleapis.com/brella-archives/Code%20Golf/Magneson/always_invisible_ink.png)
This is my first submission in a long while, so while I think Magneson does classify as a language according to [this](https://codegolf.meta.stackexchange.com/questions/2028/what-are-programming-languages/2073#2073), if it's not suitable let me know and I can take it down.
Onto the "code" itself; Magneson operates by parsing an image and evaluating commands from the colours of the pixels it reads. So stepping through the image for this challenge, we have:
* `R: 0, G: 0, B: 1` is a simple `println` statement; it prints a string out to the console
* `R: 255, G: 255, B: 0` is a string operative to concatenate the following values, until we receive a stop concatenate op.
* `R: 2, G: 0, B: 27` is a raw character. In strings, when the red component is `2` and the green component is `0`, we simply use the blue component as a raw character to add to the string. In this case, we add the escape character for ANSI control strings.
* `R: 2, G: 0, B: 91` is another raw character (`[`)
* `R: 2, G: 0, B: 51` is another raw character (`3`)
* `R: 2, G: 0, B: 48` is another raw character (`0`)
* `R: 2, G: 0, B: 59` is another raw character (`;`)
* `R: 2, G: 0, B: 52` is another raw character (`4`)
* `R: 2, G: 0, B: 48` is another raw character (`0`)
* `R: 2, G: 0, B: 109` is another raw character (`m`)
* `R: 3, G: 0, B: 0` is a string operative for input from STDIN. In this case, it just appends it to the concatenated string.
* `R: 255, G: 255, B: 1` is the end concatenation op.
All in all, this program builds a string of `ESC[30;40m`, followed by one line of input from the command line. This'll set both the foreground and background colours to black.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 77 91 bytes
```
c;main(){printf("\x1b]11;2\a\x1b[42;32m");while((c=getchar())>0)putchar(c);puts("\x1b[m");}
```
[Try it online!](https://tio.run/##JYtBDsIgFAWv8tMVLEwE3RE9hbvWBf1SQEtBCrZqPDu26W5e5g3uNGIpKJy0A6HfEO2QOlI1M2uvjAneyBXrIxcH7ioqJmN7RQietEpoZCSUnvc05G0gFQuOW1@v/18pF6PgmS0@oI1@GqDzM9yzCyP4l4qQFt3LzxtuXv8B "C (gcc) – Try It Online") (will only show the raw output including the escape sequences)
Extra bytes were necessary to be independent from the original background color, see discussion in the comments.
This version uses ANSI escape codes to set the background and foreground colors to green as well as an Xterm escape code to change the background of the whole window to green. This way, if your selection color doesn't happen to be (dark) green (very unlikely), it **will** work on terminals supporting ANSI escape sequences and compatible with Xterm.
It works for example in `rxvt` as seen in these screenshots:
[](https://i.stack.imgur.com/83JB6.png)
[](https://i.stack.imgur.com/bYFGU.png)
[](https://i.stack.imgur.com/IOHB2.png)
] |
[Question]
[
*Thanks to [HyperNeutrino](https://codegolf.stackexchange.com/users/68942/hyperneutrino) for making more test cases*
Often in [chat](https://chat.stackexchange.com/rooms/240/the-nineteenth-byte), someone will ask a question, and multiple people will answer it at the same time. Usually, the person who was beaten to the gun will say "ninja'd", creating even more unnecessary chat.
Given a chat log similar to the following:
```
Community: Hi
Test: Hi
Rando: What is 4 times 4?
Test: @Rando 16
Community: @Rando 16
Community: ninja'd
```
You are looking for the number of extraneous lines, which in the above exchange is 2. Two users both replied to another user with the same text, although he only wanted one answer, and then the second user said "ninja'd".
# Extraneous Messages
Note that for the following statement, a message is only the content left of the `:<space>`. However, if an extraneous message is removed, the `<username>:<space>` is also removed.
Your only task is finding extraneous messages in the input, and counting them. The first type of extraneous message is a message **starting with `@`** that is basically (spaces and case differences are ignored) the same as the message before it. The second type of extraneous message is a message reading exactly `ninja'd` (case insensitive) immediately after an extraneous message of the first type **by the same user** (there will never be users with the same name in different cases, and the same user will always be in the same case).
# Input
Your input is the chat log, including the user's names, followed by a colon and a space, followed by their message. You may take the input as a newline-separated string, a list of strings, or another appropriate input format.
# Output
Your output is the number of extraneous messages.
# Test Cases
```
Community: Hi
Test: Hi
Rando: What is 4 times 4?
Test: @Rando 16
Community: @Rando 16
Community: NINJA'D
2
```
```
A: how is everyone doing today
B: good
C: good
C: this doesn't work: `print5`
A: @C add a space
B: @C add aSpace
B: ninja'd
C: ninja'd
2
```
```
A: test
B: @A hi
C: @Ahi
C: ninja'd
2
```
```
A: test
B: @A hi
B: @A hi
B: ninja'd
2
```
```
A:
B: @
B: @
B: ninja'd
B: ninja'd
2
```
```
A: ninja'd
B: ninja'd
C: @B ninja'd
B: @B ninja'd
B: ninja'd
C: ninja'd
C: ninja'd
2
```
```
Test: test
Testie: @Test TESTIE
Test: @Testie TESTIE
Test: ninja'd
Testie: TESTIE
Test: TESTIE
0
```
```
A: @B hi
C: @B hi
C: ninja'd
B: @C no
A: @CNO
A: ninja'd
4
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 50 bytes
```
T`l`L
(:@.*)¶(.+)\1
b$2a
b(.*)a¶\1:NINJA'D
aa
a
```
[Try it online!](https://tio.run/##K0otycxL/P8/JCEnwYdLgYtLw8pBT0vz0DYNPW3NGEOuJBWjRK4kDaBQ4qFtMYZWfp5@Xo7qLlyJiVxAXY5WCg5OChmZXM5IjLzMvKxE9RQuJ6CYs0JePhdIlbOfP4iGygEA "Retina – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 237 bytes
```
l=lambda s:s[1].lower().replace(' ','')
m=[x.split(': ')for x in input()]
i=[0]
for j in range(1,len(m)):i+=[[m[j][1].lower()=="ninja'd"and i[-1]>1and m[j-1][0]==m[j][0],2][l(m[j-1])==l(m[j])and'@'==m[j][1][0]]]
c=i.count
print c(1)+c(2)
```
[Try it online!](https://tio.run/##TZBRb4MgFIXf/RU3vgCpM9VkLyY03foT9khIyoQpDsEgnfXXO7Qza3IfvntyziHcYQ6ts@WyGGpE/ykFjNXICp4bNymPSe7VYEStMAKUIUSSnrJ7Pg5GB4wqQOTLebiDtnGGW8CEJ5qyI09WvVt1L2yjcJEZZXFPSKUPlLGedfzpFUpTq20nkEyFlaDZS8FPxYrRGDkWUrpljjwrOTP4ocfghpxELzqjP9MW4Dypqc5rd7MhGby2AWpckEONS7IsLH2roHUT6BHUj/Kzswqk07aB4KSY0yx9r6BxTka6PFNoY0Q6NVoUYHL@u4LrVv96jYbYer6AkBLiJYd4uEfRrn38S/uHt9J94b8 "Python 2 – Try It Online")
-19 bytes thanks to Zacharý
[Answer]
# [Python 3](https://docs.python.org/3/), 122 bytes
```
lambda s:sub(r"b(.*)a\n\1:NINJA'D",'aa',sub(r'.+(:@.*)\n(.+)\1',r'b\2a',sub(' ','',s.upper()))).count('a')
from re import*
```
[Try it online!](https://tio.run/##TYy9DoMgFIV3noK4XFRCYruZNPGnSzvYF2DBqpGmAgEcfHqKrUPvck7O9@Wazc9ancN04eEtln4Q2JVu7YlNesKyVHDFi7K7dfcargkFIYB@MbCclFU0uCIsT3kB1ELPTwcHDBRiZasxoyVpPPbUq/IEBKRosnrBdsRyMdr6LPwSu80hY2W0JhI7c36QitlRDPuHUJe4avAsUftXlFQvAQNq4tZipdFutd1jz4N9AA "Python 3 – Try It Online")
Port of my Retina answer
] |
[Question]
[
**This question already has answers here**:
[Split string into n pieces (or pieces of length n)](/questions/77310/split-string-into-n-pieces-or-pieces-of-length-n)
(11 answers)
Closed 6 years ago.
Given a string and integer n, split the string at n character, and print as follows:
Ex)
`laptop 3` should print `lap top`
`laptop 2` should print `la pt op` (see how it splits the string at every 2nd char)
Special cases:
`laptop 0` should print `laptop` (since we split at every 0th char, thus none)
`laptop 9` should print `laptop` (since length of laptop < 9, so no splitting)
`bob 2` should print `bo b` (we split at the `o` (2nd char), but then there aren't enough characters after, so we just leave as is`
You may assume n >= 0
[Answer]
# JavaScript, ~~54~~ 47 bytes
```
s=>n=>n?eval(`s.match(/.{1,${n}}/g)`).join` `:s
```
```
f=
s=>n=>n?eval(`s.match(/.{1,${n}}/g)`).join` `:s
console.log(
f('laptop')(0),
f('laptop')(1),
f('laptop')(2),
f('laptop')(3),
f('laptop')(4)
)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 bytes
```
òVªLl)¸
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=8laqTGwpuA==&input=ImxhcHRvcCIgMg==)
### Explanation
```
Implicit: U, V = inputs
UòV ) Split U into slices of length V.
ªLl If V is 0, instead use 100! (roughly 9.3326e+157).
¸ Join with spaces.
Implicit: output result of last expression
```
9.3326e+157 is far larger than JavaScript's max string size of 9.0072e+15, so this will work for any input.
[Answer]
# PHP, 48 bytes
```
[,$s,$n]=$argv;echo$n?chunk_split($s,$n," "):$s;
```
Run with `-r`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
sW⁹?K
```
A full program printing the result (or a dyadic link returning a list of characters).
**[Try it online!](https://tio.run/##y0rNyan8/784/FHjTnvv////K@UkFpTkFyj9NwIA "Jelly – Try It Online")**
### How?
```
sW⁹?K - Main link: list of characters, a; number, n
? - if:
⁹ - chain's right argument = n (0 is not truthy, positive integers are)
s - then: split a into chunks of length n (overflow kept like the challenge requires)
W - else: wrap a in a list
K - join with spaces (the wrapped list becomes depth 1 again with no spaces)
- implicit print
```
[Answer]
## Haskell, 33 bytes
```
import Data.List
s!n=chunksOf n s
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 11 bytes
```
q~:X{X/S*}&
```
[**Try it online!**](https://tio.run/##S85KzP3/v7DOKqI6Qj9Yq1bt/3@lpPwkJQUjAA "CJam – Try It Online")
### How it works
```
q~ e# Read all input and evaluate. Pushes the string and the number n
:X e# Store n in variable X
{ }& e# If top of the stack (number n) is nonzero, run this block
X e# Push N again
/ e# Split into pieces that long. Last piece may be shorter
S e# Push space
* e# Join using spaces
e# Implicitly display
```
[Answer]
# [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ), 27 bytes
```
_L;|~:|\b=a][1,a,b|?_sA,c,b
```
## Explanation
```
_L;| set a as the length of A$ (input from cmd line)
~:| IF b (input num from cmd line) is anything but 0 THEN (empty)
\b=a ELSE (b==0) set b to the full length of A$
] END IF
[1,a,b| FOR c = 1; c <= LEN(A$); c = c + b
?_sA,c,b PRINT a substring of A$, starting at c, running for b chars.
NEXT is auto-added at EOF
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~76~~ ~~67~~ 56 bytes
*-13 bytes thanks to ETHproductions and notjagan.*
```
lambda s,n:n and[s[i:i+n]for i in range(0,len(s),n)]or s
```
[Try it online!](https://tio.run/##DckxDoAgEATAr1wHRAqjHYkvUYszgl6CCwEaX49OO/ltd8LUw7L1yM9xMlULB2Kca13FyYA9pEJCAiqMy@vRRg9djYXZ/6k9F0GjoFXk3FJWlmbTPw "Python 2 – Try It Online")
## Regex solution, 56 bytes
```
lambda s,n:re.findall('.{1,%i}'%n or len(s),s)
import re
```
[Try it online!](https://tio.run/##BcFBCoAgEADAe6/YS6ggQnUL@kkXQyVhXZfVS0Rvtxl@@l1pHek4B/pyBQ/N0i7RpUzBI2rl3sXO@VMzQRXASLoZ28yUC1fpIHGwZOqQtELPvbKysJnxAw "Python 2 – Try It Online")
[Answer]
# Mathematica, 114 bytes
```
d=StringRiffle;If[#2>(s=StringLength@#)||#2==0,#,k=d@StringPartition[#,#2];If[#2<=s/2,k,d[{k,StringDrop[#,#2]}]]]&
```
] |
[Question]
[
This is a Code Golf challenge.
[Flood](http://www.chiark.greenend.org.uk/~sgtatham/puzzles/js/flood.html) is a game in which the player is presented with a game board such as this:
[](https://i.stack.imgur.com/RWaO2m.png)
On each turn, you choose a colour (on the link above, by clicking a square containing that colour), and the cell in the top-left corner is filled with that colour - this colour will absorb all adjacent cells with the same colour. So, for example, the first turn might be Blue, which will cause the yellow cell in the top corner to turn blue, and merge with the existing blue cell. The next turn might be Purple, which will fill both of the first two cells purple, merging them with the two-cell purple area attached to them. Then you might go Red, then Orange. With this sequence, the board will end up as:
[](https://i.stack.imgur.com/hMfVFm.png)
Your task is to write a code that simulates the game, taking in an array or other data format containing the current state of the game, in a suitable format (picture, numbers in a square array, string with numbers indicating the dimensions, anything that can be identified with the game), along with one or more input commands (colours, cells that contain colours, etc - your choice of how to implement the sequence, but you need to explain it).
If (and only if) the input solves the board (causes all cells to be the same colour), then your code should print a message in some format informing the player that the board is cleared or completed. It is up to you how this is done, but it must be clear to any English speaker using the code without requiring separate documentation (so outputting "1" isn't good enough). Note that displaying a completed board is not sufficient.
Some example options for completion output include `win`, `done`, `complete`, or `clear`. If your language doesn't have a nice way to output a longer message, I recommend using `win`.
Whether the input solves the board or not, the code should output (either as function output or as a displayed output) the final state of the board.
The code may take input of moves interactively (from STDIN, to simulate the actual game) or as a code input.
## Scoring
Your goal is to minimise the number of bytes in the function or code.
## Rules and Assumptions
[Standard Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
Code must be able to handle non-square boards, with each dimension being anywhere between 6 and 30 cells (more is fine, it must handle this range). It must be able to handle between 3 and 9 distinct colours or "colour" labels (numbers are fine).
You may assume that input is in simplest form - that is, if there are four colours, they will be labelled 1-4, or a-d, or any other similar system as appropriate. You will not need to handle situations such as incorrect inputs, unsimplified inputs (you won't have the numbers 1, 3, 6, and 9, without the others in between, unless it suits your code).
Your answer should include a description of formats, etc.
**Request**: If you believe you have identified a non-standard loophole, and it's definitely a loophole and not in the spirit of the question, please comment to have the loophole closed, rather than posting an answer using it. This is not a rule, *per se*, but an effort to keep the challenge interesting.
[Answer]
# Octave, ~~68~~ ~~64~~ ~~94~~ ~~92~~ 83 bytes
```
a=f(a,s)m=a;for k=s;[~,x]=bwfill(a~=k&m,1,1,4);m(x)=0;a(x)=k;end;~m&&puts("win\n");
```
A function that takes as input a matrix `a` and a vector `s` as the sequence of commands and outputs the final state of the board.
Explanation:
```
function a=Flood(a,s)
m=a;
for k=s
[~,x]=bwfill(a~=k&m,1,1,4);
m(x)=0;
a(x)=k;
end
~m&&puts("Game Completed\n");
end
```
Usage:
```
num_colors = 4;
a = randi(num_colors, 5 ,7)
s = randi(num_colors, 1 , 15);
Flood(a,s)
```
Use `m` as a mask representing the filled region so far. Repeatedly run commands and flood fill the masked grid from the top left corner.
] |
[Question]
[
I have a problem when posting an answer to a question that already have several answers and/or several comments:
The "post your answer" form sits on bottom, the answer is on top. There is an awful lot of "clutter" between them, that are not needed for the act of posting a new answer (yes, I've read the other answers and comments, what I am about to write is original).
I have a very short short term memory and hate to scroll all the way up and down to read question and write answer text.
Write a script or program that
* Can run on vanilla (downloaded from the main page for those softwares) Firefox and/or Chrome (irrelevant if it also runs on other browsers or on all browsers)
you get 10 fake internet points from me if it runs on all browsers, but this is not a victory condition
* You can call any code that ships with the browser, loads with the SE page (like jQuery) or sideloads from the web.
* Can be run (as a bookmarklet, from console, any input method) on a fresh install of one of those two browsers.
* Does not depend on any other software installed on the machine, or the installation of any add-ons and/or plugins on the browsers.
* Irrelevant if it runs only on windows, only on mac or only on linux, as long as those browsers can be downloaded from the browsers' official download page, for that platform.
* Does not break the submit answer form (I can still write my answer and submit, and the whole edit toolbar is still intact - including the help icon).
* Question is intact. Title, body, votes panel, post menu and owner signature.
(italics denote editted-in content)
* *vertical* Distance between *bottom* of owner signature and *the top* of edit toolbar is the same or smaller *(negatives allowed)* than when posting the first answer to a question in the same site.
* *Edit form toolbar cannot be higher than the question title.*
+ *both question, answer edit form, answer toolbar and answer preview have to remain visible and non-overlapping.*
* Only the screen display matters. If the other elements were hidden, deleted, moved, ejected into outer space or phase-shifted into a [Dirac Sea](http://en.wikipedia.org/wiki/Dirac_sea) is irrelevant.
Your code must work for a minimum of:
* <https://stackoverflow.com/>
* <https://superuser.com/>
* <https://codegolf.stackexchange.com/>
* <https://rpg.stackexchange.com/>
* <https://android.stackexchange.com/>
* <https://scifi.stackexchange.com/>
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes will win!
---
I am now required to [link this question](https://codegolf.stackexchange.com/q/22993/31779) for the exerpts' credits. Thanks [@Doorknob](https://codegolf.stackexchange.com/users/3808/doorknob).
P.S.: It is my first time in PpCG, be kind.
[Answer]
## JavaScript, ~~35~~ 34 bytes
```
$(answers).before($('#post-form'))
```
[Answer]
## JavaScript (38 bytes)
```
$('#question').append($('#post-form'))
```
] |
[Question]
[
Your program will be run an undetermined amount of times. On all but the last, there will be a file called `data` in the same directory of your program that has the same value each time. On the last run, the file will be there but will have different data in it. On all the times *except* the last, you can do whatever you want, as long as the following rules are met:
* **Don't output anything**
* **Don't change `data` file**
On the *last* run, you must print out the diff of the first `data` file and the current `data` file.
**Rules:**
* **You *may* save whatever you want in any files you want, just don't edit the `data` file**
**Scoring:**
* **Lowest char score wins**
Cheating encouraged. You have *no* indication of which run you're in *except* that the `data` file is changed.
[Answer]
## Bash (31)
```
[ -e x ]&&diff data x;cp data x
```
Kinda obvious.
[Answer]
Here it is with good ol' Windows batch:
```
@echo off
if exist lastdata goto compare_data
type data > lastdata
goto end
:compare_data
fc data lastdata > nul
if errorlevel 1 goto last
if errorlevel 0 goto end
:last
fc data lastdata
del lastdata
:end
```
] |
[Question]
[
### Challenge:
Write a a program to take an array of 24 4-letter strings, and output a compressed (lossless) representation of the array. You should also provide a program to decompress your representations.
### Input:
The input will be comprised of 4 letter words using each of `[G,T,A,C]` exactly once (e.g. `GTAC`, `ATGC`, `CATG`, etc). There are always exactly 24 words, so the full input is something like:
```
GTAC CATG TACG GACT GTAC CATG TACG GACT GTAC CATG TACG GACT GTAC CATG TACG GACT GTAC CATG TACG GACT GTAC CATG TACG GACT
```
So there are \$4!=24\$ possibilities for each word, and 24 words in total.
### Output:
The output should be a printable ASCII string that can be decompressed back into the input string. Since this is lossless compression, each output should match to exactly one input.
### Example:
```
>>> compress(["GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT"])
"3Ax/8TC+drkuB"
```
### Winning Criterion
Your code should minimize the output length. The program with the shortest output wins. If it's not consistent, the longest possible output will be the score.
**Edit**: Based on helpful feedback comments, I would like to amend the criterion to add:
If two entries have the same results, the shortest code measured in characters wins. If an entry is length dependent, a length of 1 million words is the standard.
However, I fear the community angrily telling me I didn't say it right and downvoting me to the abyss, so I leave to community editors to see if it makes sense with code golf traditions
[Answer]
## Python (output-length: 18 or 19, mean 18.80)
```
#list of the 24 possible words
Lbase = ['GTAC','GTCA','GATC','GACT','GCTA','GCAT','TGAC',\
'TGCA','TAGC','TACG','TCGA','TCAG','AGTC','AGCT','ATGC',\
'ATCG','ACGT','ACTG','CGTA','CGAT','CTGA','CTAG','CAGT','CATG']
#base-64 alphabet (used only in the output string-representation)
alph = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/'
#change a bijective list-representation base from b to newb
def chg_bij_base(L, b, newb):
n = sum([L[i]*b**i for i in range(len(L))])
L = []
while n > 0:
L.append(1+(n-1)%newb)
n = (n-1)//newb
return L
#convert a bijective list-repr. to base-64 string-repr.
def list_to_str(Lin):
L24 = [Lbase.index(w)+1 for w in Lin]
L64 = chg_bij_base(L24,24,64)
return ''.join([alph[i-1] for i in L64])
#convert a base-64 string to the corresponding base-64 list-repr.
def str_to_list(s):
L64 = [alph.index(c)+1 for c in s]
L24 = chg_bij_base(L64,64,24)
return [Lbase[i-1] for i in L24]
```
Test run:
```
Lin = ["GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT", "GTAC", "CATG", "TACG", "GACT"]
#convert input list to a base-64 string
lts = list_to_str(Lin)
#convert the base-64 str back to the list
stl = str_to_list(lts)
print(len(lts))
print(lts)
print(stl == Lin)
```
Test output:
```
18
acFZIBuiiZJ+dwUn2V
True
```
This uses [bijective numeration](https://en.wikipedia.org/wiki/Bijective_numeration) (which has no 0 digit) to get invertibility.
**NB**: When using base-64 with this method, all output strings for the above problem are either 18 or 19 characters. (A million random inputs gave an average of 18.80.) The same method works with other bases:
```
base output-length
--------- -------------
56 - 58 19
59 - 69 18 or 19
70 - 73 18
74 - 88 17 or 18
89 - 96 17
... ...
233 - 256 14
```
] |
[Question]
[
A fragmented file is a file which is seperated into several parts on a harddrive, because it can't fit into a certain space.
On all harddrives, there are files called unmovable files, which are unmovable. To simulate real data on a harddrive, the input will also have unmovable files.
You are given several sequences of consecutive numbers, all scrambled into one list. The goal is to order each of these sequences so that they are placed in as little space as possible. *The list can be as big as you need it to be.* If there is no space for a sequence, then put a `-` instead.
To mark the unmovable files, another list, with the same length as the data, will be given after you recieve the data. It will contain either a 0 or a 1. Every 1 within that list means that the corresponding item in the data is unmovable.
Shortest code wins.
**Test Cases**
The output does not have to be exactly like this, but the length needs to be the same, and all of the sequences need to be ordered.
```
[ 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0]
[25, 30, 11, 12, 13, 14, 68, 69, 31, 26, 32]
Output: [25, 26, 11, 12, 13, 14, 68, 69, 30, 31, 32]
(output length: 11)
[0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
[2, 3, 5, 14, 8, 10, 11, 12, 4, 6, 28, 30, 29, 15, 16, 7]
Output: [14, 15, 16, -, -, 10, 11, 12, 2, 3, 4, 5, 6, 7, 8, 28, 29, 30]
(output length: 18)
```
[Answer]
## APL (~~132~~ ~~126~~ ~~123~~ ~~147~~ ~~145~~ 143)
This was a bit harder than I thought it'd be :)
Edit: the hard drive is infinite :S. All sequences that could not fit in the original space, are now appended onto the end of the output.
```
F←⍬⋄{×⍴⍵:∇1↓⍵⊣{∨/P←S⍷⍨1⍴⍨⍴⍵:S[R]∘←0⊣D[R←1-⍨(⍳⍴⍵)+⌊/P/⍳⍴P]∘←⍵⋄F∘←F,⍵}⊃⍵⋄D[S/⍳⍴S]∘←'-'}G[⍒⊃∘⍴¨G←K⊂⍨1≠|-⌿K,[÷2]¯1⌽K←K[⍋K←(S←~⎕)/D←⎕]]⋄F,⍨D/⍨~⌽∧\⌽S
```
This is what it does to your 1st and 2nd example ~~(the 2nd example is different, but in your example the output length is not the same as the input length and you said in a comment it was wrong, so...)~~
```
⎕: 25 30 11 12 13 14 68 69 31 26 32
⎕: 0 0 1 1 1 1 0 0 0 0 0
25 26 11 12 13 14 30 31 32 68 69
```
```
⎕: 2 3 5 14 8 10 11 12 4 6 28 30 29 15 16 7
⎕: 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0
14 15 16 - - 10 11 12 2 3 4 5 6 7 8 28 29 30
```
Explanation:
* `F←⍬`: set `F` to the empty list. This will hold the overflow.
* `K←K[⍋K←(S←~⎕)/D←⎕]`: read two lists. The first list (numbers) is stored in `D`. The second list (whether the data is unmovable) is *inverted* and then stored in `S`. Get all movable numbers, and sort them. Store this in `K`.
* `G←K⊂⍨1≠|-⌿K,[÷2]¯1⌽K`: Subtract each element of `K` from the next element of `K`. Wherever this is not 1, we found the beginning of a new sequence. Store the list of sequences in `G`.
* `G[⍒⊃∘⍴¨G`...`]`: sort the list of sequences by descending length. This way, we place the longest sequences first.
* `{×⍴⍵:...}G`: as long as this list of sequences is not empty...
* `∇1↓⍵⊣`: handle the tail of the list, after...
* `{...}⊃⍵`: doing the following with the head:
* `∨/P←S⍷⍨1⍴⍨⍴⍵`: find, in `S`, a list of ones that is as long as the current sequence (`⍵`).
* `S[R]∘←0⊣D[R←1-⍨(⍳⍴⍵)+⌊/P/⍳⍴P]∘←⍵`: if there is one, store `⍵` in `D` at the first position that it fits, and mark these positions as unmovable in `S`.
* `⋄F∘←F,⍵`: if there is no room, add it to the overflow.
* `⋄D[S/⍳⍴S]∘←'-'`: when we're at the end of the list of sequences, all positions where `S` is still one are places where we couldn't put anything. Mark these with `-`.
* `⋄F,⍨D/⍨~⌽∧\⌽S`: then, at the end, display D, with the trailing `-`s removed, followed by the overflow (`F`) per the new rules.
[Answer]
I decided to tackle this solution in Scala, taking advantage of both functional and imperative features of the hybrid language. Here is the code for my solution.
```
def orderedSequences(filePieces: List[(Int,Int)]): List[List[(Int,Int)]] = {
def orderedSequencesR(filePieces: List[(Int,Int)], currentSequence: List[(Int,Int)], sequences: List[List[(Int,Int)]]): List[List[(Int,Int)]] = {
if(filePieces == Nil) sequences :+ currentSequence
else if(currentSequence == List.empty) orderedSequencesR(filePieces.tail, List(filePieces.head), sequences)
else if(filePieces.head._2 == currentSequence.last._2 + 1) orderedSequencesR(filePieces.tail, currentSequence :+ filePieces.head, sequences)
else orderedSequencesR(filePieces, List.empty, sequences :+ currentSequence)
}
orderedSequencesR(filePieces, List.empty, List.empty)
}
def defragment(sequences: List[List[(Int,Int)]], filePieces: List[(Int,Int)]): List[Any] = {
val largestSequenceLength = sequences.flatten.length
var solution = scala.collection.mutable.ListBuffer[(Int,Int)]()
filePieces foreach {filePiece => if(filePiece._1 == 1) solution += filePiece else solution += ((-1,0))}
solution ++ Iterator.fill(largestSequenceLength)((-1,0))
sequences foreach {
sequence =>
var sequenceIsInserted = false
var currentPosition = 0
while(!sequenceIsInserted) {
if(solution.slice(currentPosition,currentPosition + sequence.length).forall((s: (Int,Int)) => s._1 == -1)){
solution = solution.slice(0,currentPosition) ++ sequence ++ solution.slice(currentPosition + sequence.length, solution.length)
sequenceIsInserted = true
}
currentPosition += 1
}
}
solution.map(_._2).toList
}
def getDefragmentedFiles(isUnmovable: List[Int], files: List[Int]) = {
val filePieces = isUnmovable zip files
val sequences = orderedSequences(filePieces.filter(os => os._1 == 0).sortBy(t => t._2))
val bestSolution = defragment(sequences.permutations.toList.sortBy {b => defragment(b, filePieces).length}.head, filePieces)
println(bestSolution map { case 0 => '-'; case x => x })
}
val isUnmovable = List(0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0)
val files = List(2,3,5,14,8,10,11,12,4,6,28,30,29,15,16,7)
getDefragmentedFiles(isUnmovable, files)
```
I take the list of movable/unmovable positions along with the files and zip them up. I then get the movable files, sort them in order, and pass them into orderedSequences to get a list of file sequences.
Once I get the sequences, I get all the permutations of the sequences and I brute-force defrag them, taking the solution of the shortest length. This is pretty inefficient, but I can't think of a more efficient solution right now. The defrag method takes each sequence, in order, and iterates through the memory space until a valid spot to place the sequence is found.
After getting the best solution, I prettify it and print it out as a list.
] |
[Question]
[
# Can you decrypt me?
## Cops
Cops, post obfuscated code that hides a number \$n\$ (n must not be greater than the program length) inside its code. If \$n\$ chars are changed (no additions or deletions), the program outputs exactly one \$n\$ (any amount of whitespace before or after is allowed.) Otherwise, it outputs something else. Both programs may not error, and there can be multiple solutions.
## Example
```
print(2)
```
N is 1.
---
Robbers' post:
```
print(1)
```
## Scoring
For the cops, the user with the most uncracked posts wins. If there is a tie, the user with the total minimum byte count wins.
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), 5204 bytes [Cracked (intended way also listed)](https://codegolf.stackexchange.com/questions/269183/can-you-decrypt-me-robbers/269342#269342)
```
#include <iostream>
using namespace std;
string secret = "secret";
void f1(){if(secret.length()!=6){cout<<"1111111";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1111111";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1111111";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1111111";return;}}}}}}}}
void f2(){if(secret.length()!=6){cout<<"1111111";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1111111";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1111111";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1111111";return;}}}}}}}}
void f3(){if(secret.length()!=6){cout<<"1111111";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1111111";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1111111";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1111111";return;}}}}}}}}
void f4(){if(secret.length()!=6){cout<<"1111111";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1111111";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1111111";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1111111";return;}}}}}}}}
void f5(){if(secret.length()!=6){cout<<"1111111";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1111111";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1111111";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1111111";return;}}}}}}}}
void f6(){if(secret.length()!=6){cout<<"1111111";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1111111";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1111111";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1111111";return;}}}}}}}}
void f7(){if(secret.length()!=6){cout<<"1111111";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1111111";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1111111";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1111111";return;}}}}}}}}
int main() {
f1();
f2();
f3();
f4();
f5();
f6();
f7();
cout<<6;
f1();
f2();
f3();
f4();
f5();
f6();
f7();
}
```
[Try it online!](https://tio.run/##7ZhNb6MwEIbv@RVuKm1BoauQD3ow7h@JOACBrMHYfFaqKL89O7YDC4dKPewFyT5E78zDjCfDeyIuy9dbHN/vz5THrLsmyKeiaeskLN43XUP5DfGwSJoyjBPUtFe8ASizTRLXSYsI2mq1xZsPQa8odS27p6mls79Zwm/tH8t@Ip7dx6JrfX/r6rPF8EBXczxQ3qLw4gWk11WXffD6gl6cR@QuosMiOi6i0yI6q2jAqagteQUle0z9M6a7nRoxvNDgncDvzg2@H25YlnuLcp/sv75UH6j5UQ8XehCAus2YzwgMgTNNsjnJSQYk1ySfE0ZyIEwTNicFYUAKTYo54aQAwjXh6o9ANlK7p07m5A5zCocPOBKCoc/wk6Qha5JphQLmF77l@r5nYzHvXAIpR1KOncOmK@Ta5CVajs9XoCvYZvXYpvglayvb7mXNDl5LFYAzUqucQKRApIAkqjmRWbuXo7Z1l@AIrJtrDjko@hc/qcS370ifh4sPxsXGxat38dG42Lh49S4@GRcbF6/exWfjYuPi1bvYMy42Ll69i9@Mi42LV@xitcCQcstG/QbBkV/dsFaHSR0ndZrUeVLepN5Gpa/18H9qOdzvfwE "C++ (gcc) – Try It Online")
Same as my previous submission, hopefully it is a bit more radiation hardened.
\$n = 6\$.
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), 4960 bytes, [Cracked](https://codegolf.stackexchange.com/questions/269183/can-you-decrypt-me-robbers/269214#269214)
```
#include <iostream>
using namespace std;
string secret = "secret";
void f1(){if(secret.length()!=6){cout<<"1";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1";return;}}}}}}}}
void f2(){if(secret.length()!=6){cout<<"1";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1";return;}}}}}}}}
void f3(){if(secret.length()!=6){cout<<"1";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1";return;}}}}}}}}
void f4(){if(secret.length()!=6){cout<<"1";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1";return;}}}}}}}}
void f5(){if(secret.length()!=6){cout<<"1";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1";return;}}}}}}}}
void f6(){if(secret.length()!=6){cout<<"1";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1";return;}}}}}}}}
void f7(){if(secret.length()!=6){cout<<"1";return;}int a[6]={secret[0]-' ',secret[1]-' ',secret[2]-' ',secret[3]-' ',secret[4]-' ',secret[5]-' '};for(int i=0;i<5;i++){if(a[i]>=a[i+1]){cout<<"1";return;}}for(int i=0;i<6;i++){if(a[i]<=0||a[i]>111){cout<<"1";return;}}for(int i=1;i<=111;i++){for(int j=i+1;j<=111;j++){for(int k=j+1;k<=111;k++){for(int l=k+1;l<=111;l++){for(int m=l+1;m<=111;m++){for(int n=m+1;n<=111;n++){int b[6]={i,j,k,l,m,n};bool yay=false;for(int o=1;o<(1<<6);o++){for(int p=1;p<(1<<6);p++){int asum=0;int bsum=0;for(int q=0;q<6;q++){if(o&(1<<q)){asum+=a[q];}if(p&(1<<q)){bsum+=b[q];}}if(asum==bsum){yay=true;break;}}if(yay){break;}}if(!yay){cout<<"1";return;}}}}}}}}
int main() {f1();f2();f3();f4();f5();f6();f7();cout<<6;f1();f2();f3();f4();f5();f6();f7();}
```
[Try it online!](https://tio.run/##7ZjNbqMwEIDveQo3K7Wg0CpuG/YwuC8ScQACWfNj87tSRXn2dGwnLUiVdq9IziHyzOcZO@YTIiR1/XhOksvlFxdJOZxSEnDZ9W0aVW@boePiTERUpV0dJSnp@hNsEKpslyZt2hNGtma0hc1fyU8ko4478swx2acyFef@j@PeMd8dEzn0QbClW0A0tAImLnoSHf2QjWb@cR8@PpAH7xrRRfS8iF4W0esiOuhogky2jlqCsz3w4AB8t9Obi448fGP4vaPhT9ualoX@ojBg@48P3YFS@o9qitUMp5kGt3zOcGHIDcnnpGA5ksKQYk5KViApDSnnpGIlksqQak4Eq5AIQ4T@CZiN9XlzL/cKr/QqT0wQS1mS9@idZVHZpV/HJnH/MnBoEPguyHnnGkl9I/Wtc9QNlTowtYgZ3uY3OG7wHJvrOcp7Vdu47qhqdngpmhBtyJz6C8QaxBooopszlXVHtdW@HVKIUdTCcMxh0Xd8pxM/XB3zudr6bG21tq7G1hdrq7V1Nba@Wlutraux9WBttbauxlbf2mptXY2tv62t1tYV2KqPLuLCccmoXmSBej8A6m8XqKdZUA8JoO69oJQG08iH/5g6XS6f "C++ (gcc) – Try It Online")
Intended solution only modifies the characters in secret, and also takes very long to run.
The hidden n is \$6\$. If unchanged, the program outputs \$111111161111111\$.
[Answer]
# [Python](https://www.python.org), 669 bytes, \$n = 1\$, [Cracked](https://codegolf.stackexchange.com/a/269245/91267)
```
import lzma
exec(lzma.decompress(b'\xe0\x00E\x00A]\x004\x9bJg\xb8R<s\xda\xb0\xe5\xbe\xe9\xde\t\x02\x8d\x9d\x02LW\x8bw\x87\xf3mkn1\xc5\xd9\xd6\xe9\xc9E\xf25\xd3\xd7\x01\x91\xc2FM4\xe5sW\xd6\xaaR\x07j\xe7\xa3\x80\x05b\xfcZ9\x0en5\xc2\x00\x01\x00\x00r\x00\xe0\x00\x86\x00y]\x002\x9d\x88\xce\xe12k^\xffi\x8eN\xf1\x83j-\xf5\\\x86\xd9\x01\xb6\xban\xb5_B\xcb@\xeeZ\x05u\x9c,a\xf3\xd1\xf5y\x96\xd0\xf6\x11\x82y\x13\x9cUb:j\x13\xa72\xccl_J\x90*\xf0\x1b[t\x84\xcb\xad\xff>qg\xf7\xe7\x93L\x04\x8fT\x91\xfe\xc9\xd1\x84]\x9f\xcd\xa6\x9e3W[\xbb\xcb/A\xbbZr\x9fq\xf5Wj\xe4\xe0\\\xadt)\xea\xee\xa7]\x80A1\x04\x8e\x9aM\x00', format=lzma.FORMAT_RAW, filters=[{'id': lzma.FILTER_LZMA2}]))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NVJda9tAEIQ-9lf4zXFJWn3Gp9CUqpBAg92CcBHY55o76a61Y9mOpBC5pb-kBPKS_Kj8ms740gfdjlYzu7Or-_u027c_t5uHh8fb1p6I51f3y2q3rdve-lelXpvOFEdEb0tTbKtdbZrmSPdlZzzZed4Fj3TOM5Jdoq9-yE6L7H0ju1IBgmRiRIOYIGdkC24gO1GCXhKPcrzpOxxD2dmwut74sisgKik4dcIiQScbMBviAdMDKyEzuBxH7NLkjq5Uhq_DFXKgKdAFrcYaBYopanlmE1NH067OIXq1A24wqE4Z94fZAmdWCOg4ih9cf0c5u0TOfAFCERGuToBiKZ2W9llcA2u1wREvPkGvP6KAmdLSLcoWx4pjg-9TvUeKYhiwiD4LB0j6Ibnf9NnKYTWEp6JYL66Q996ADYWvZ1iviNgFlJIWP9zgl9ih20YSjtAX34WduPVZw-W67iLCsIlFAkqF7okJ8xmMaxZ8lxJNa1JuaDXniqPDwiS7tQNgxeFob869p_5LO6QSNeYq-8c9u60r1Z4fbtXl12ycThZZmiO_XLembs5nv_vLsn_Wc4TPo8lFthhNx2nwZz4YuFv6cln_X9p_)
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 49 bytes, n=49, [Cracked](https://codegolf.stackexchange.com/a/269287/76323)
```
++++++++++++++++++++++++++++++++++++++++++++++++.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fm0Sg9/8/AA "brainfuck – Try It Online")
Saturate question
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 723 bytes, [Cracked](https://codegolf.stackexchange.com/a/269202/91472)
```
P=3
p=[i*(P+1)+1*(i//2)for i in range(P)]
v=[(p[2]*(p[1]+1)+1)+(p[1]-1)*i for i in p]
I=[x*2-1+(v[2]-v[1]+1)*(i//2)for i,x in enumerate(v[::-1])]
t=[vars(__builtins__)[dir(__builtins__)[i]]for i in I]
m='_'.join(vars(t[0])[dir(t[0])[i]].__name__ for i in v)
M=vars(__builtins__)[dir(__builtins__)[v[2]+1]](''.join(x.__name__[:len(t)-i]for i,x in enumerate(t)))
l=t[2](M,m[2:v[1]-v[0]+1]+m[v[2]-v[1]+t[1](t[0](v[2])[-1]):])[-1::-1]
PP=[len(dir(t[2]))-p[2]-1,len(m),sum(len(dir(x))for x in t)//sum(p)+len(p)-1,I[1]%(len(dir(t[1]))+len(dir(t[2]))),sum(p)-1,sum(I)//sum(v)+len(p)-1,sum(p)-1,p[2],I[1]%(len(dir(t[1]))+len(dir(t[2]))),v[2]-v[0]-len(v)-1]
print(len(vars(t[0])[dir(t[0])[sum(PP[:P])]](t[0](),[l[i-1]for i in PP])))
```
[Try it online!](https://tio.run/##jVK9boMwEN55CpYqPsAhJEuF5AdgiOTdsiyq0tYVOBZxEH166jMUoipDFmP5vp@777A/7utiTq@2nybOTpFlQieEpwWkRUJ0nh/h49LHOtYm7mvz2RAOMhqYIFYcZeLPQgYwpOFOC0h0vFKsjComxuRIi5QMnkGHmXCvnY0Ibcyta/raNR5XlrSQ3scxMdT9lSj1dtOt0@aqFIh33f970VKulpWMOrZTu/33RRsS6E4c5Eybbx6@V8rUXaPU1usA0Zk9ZYeDpIWUZLe4jKucKNvGEAdUy4ezOQCIWua8AjlnnTiWGIhP5YCKaSe2kJw/QsMhOBAYSRm@IZ6IcybQbJ7LI4DiTmiR4WsH2fXWkT/ACCHr0I2DPMeahRTLFjyl8mYvZJPzXnN1U58FAxov1aIy3KmsAGzkOc1l3oOkWBkAJ7O9Ni4QH64PXTgXJfe/yJIQZKIV2nPXbXKO8tP0Cw "Python 3.8 (pre-release) – Try It Online")
The hidden \$n\$ is \$9\$. If unchanged, the program outputs \$10\$.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 57 bytes, n=3, [Cracked](https://codegolf.stackexchange.com/a/269226/)
```
++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fm0yg9/8/AA "brainfuck – Try It Online")
Seems this question hard to make sth interesting
[Answer]
# [Python](https://www.python.org), 873 bytes, \$n = 4\$, [Cracked](https://codegolf.stackexchange.com/questions/269183/can-you-decrypt-me-robbers/269265#269265)
```
import lzma;exec(lzma.decompress(b'\xe0\x00\x86\x00\x7f]\x00\x05\t\x8c\x1f48\x17VAca7\xfc\xaf\xf6\xcd(?\xfa\x11\xf2f\x12\xa8\xe8\xd5\xeb!\x99\xe1\xe7\x81i\x94\x9ej\xf1\x95\x1f\xdd\x83\x11\x01\x84\xb8\xa9=\xe2\xa6\xe6\x88\x8b\xb0\x8a\xacWkV\xc4!\xb4\xaf\\c\xfa\xbc\xf9\xb1\xee\x04\'\xe7d0pJ3B\x02\xcbH\xa2u\r6\xe2>4\xb8\x8f\xe1\x99\x1bW\x8c\x0cT/\xd7wt.{_\x89\t\xb1Ws\xdc\x7f.\xcc\xd6\xb8\x0f\x874\x8eH\xb4\xccq\xb7UV\x00\x00\x01\x00\x004\x00\x01\x00\x18a85aa25882b90aaa356ebd56b\x00\x01\x00\x00c\x00\x01\x00\x006\x00\x01\x00\x005\x00\x01\x00\ndf940ede04a\x00\x01\x00\x003\x00\xe0\x00T\x00A]\x002\r\x88&\x926K\xd9\xf0vNM\xc8\xee\x93\xdfB\xf5\xf5t\x85\x88:\xf9\xa5\xe0\xeb`\xc4\xbdK\xf6s%\xe4\xdf\xae\x1a\xe1-\t\x91\xda\xab\xd0\x10\xea\xa1\x9d\xcd\xec\xe9\x95hD\xb8\xfb\x90\x8e\xe8\x9d\x99"\x14\x00\x00', format=lzma.FORMAT_RAW, filters=[{"id": lzma.FILTER_LZMA2}]).decode())
```
[Attempt This Online!](https://ato.pxeger.com/run?1=XVPbbtNAEH3gR0IkaCLRsHa89m5RQEGACm1AikIiwVZhr6qhaYLtgqHiS3jpC3wUX8OZbPrQPIx3fHbmzOzZ2d9_Nz-a8_Xlzc2fqyYcin_3ynK1WVdN5-LnSj_xrbc98gbO2_VqU_m67pkD1XqmWgYTeVyLcBYdxlUD2Ko2CZnAt5iPrS5UGwDpgBUZ1vWewdPYTrCmgJMU24j3MMexmvuqlRIOIjzyRVICyGD-M3KASk5FEO6wO4xcDCYQZECj5QipxIuSHiYACoNNahzFtV18maObDKVMtm1P2diXoRXVDVX34M0UnbpwbPNm-Bz_oLXmGDnplaqIP326KytCbJqaT8wiisHs7DE6Lb43g-slIEkqmWRRA7Qk3wB8cFweSRhIRAFG4Y9jc9Z-hVO8n-90ZvGw0c_uAonQgmudciFSI5nWeshzbxzPzX6m3QfyfYDfAS5dkBnzzrNM70cOoxNnY0af8XYqUlWR-A-hSZqf4JBQJrBvbyc4lYj6SuS6AGEDJ6MR4pRzFK9B80jrzSe6LwjhTmiU6gfAMkpFDGgSTdofkrgSbTm6ZBzZkSaUTv90NY5mEP84vZc0Secvou4B0ZLGw8dRpEgpu0i_lZgdPOqEdbXSzWj7MF69m07Gs-V0vABeXjS-qkcfr7ul6x51YsDr09nL6fL0w2Sc_jrrb1-S871-P7643cO7fYD_AQ)
This response is much like my [previous one](https://codegolf.stackexchange.com/a/269227/91267) but with an increased \$n\$ to prevent direct brute-force attacks. Understanding the [crack](https://codegolf.stackexchange.com/a/269245/91267) to the earlier version should aid in cracking this one.
[Answer]
# [///](https://esolangs.org/wiki////), 8271 bytes, \$n = 2\$, [Cracked](https://codegolf.stackexchange.com/a/269311/106959)
```
/~-/-~~//-~/~%--//-*///*\*/76543//~~~~~~~~~~~~%%%/***//~///*///%/4//-//~~~--********************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************%%%
```
[Try it online!](https://tio.run/##7csxCoBADAXR06QJhF@46mVsLAQLu@1z9TVaeQVhHiSkmPRr7@fRx1CGIlO1lBZRh0vyzbUuc5uk/DAzuVeQT1NjavXxRhEOAAAAAAAAAAAAAAB@z8zGuAE "/// – Try It Online")
If unchanged, outputs:
```
444444444444444444444444765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543765437654376543444
```
[Answer]
# [Python](https://www.python.org), 651 bytes, \$n=2\$, [Cracked](https://codegolf.stackexchange.com/a/269275/76323)
```
print(77925340277363824169293758807642437284508406489944233814731817114744334387054677199464359370358303681225801571736917189241020964424020531423054738521455432784731931386377196234255749859141710848221995*7660297729448052594468076976871308901099050010752258215140275334247136696601489292003583235840730794856813394396865245853772202539436917905108732823263342134564638227230398268672502337581353160403575356676232895580244410109024495577929416391%997624712161309143295415334518642567808466476564516128021383833912794511198191262082650250977292178811713461440089160581066992373718706289075971369001597094521060013695658387955211810675571614035311614)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=NZJbSl5BEIQhexFiINBd1dcNib4YCb8PrsEl5MUXXVRWY40XDpzpGWaqq76Zf28PT5fbP_cvL6-Pl5vf8__H88Pfu_vLz-5FMgzdLA7Ca7HsnLGuQLAxkTZhFbMbAXI8mj7eriKCDE5bRnW7tlQwJWHMobHGgRzzbFeP1alZ9THYluTU25IuXSk0J-GRGUTP6bJ0TvEoFxjI7NjJ9ZCQbA2gnvmrqwzbDVkcS6TGOhm2a9pps-a2a2kaO48nePqJnkqA0KaqlYwrKBb2EQD6hTWtNyYVhtzg1lQiclLOABNDrZ5waiBbTQyIOsLOyIoDF62Q3IFON9KEUqCdil8WaicnWdUKitkUNESIlHyfSivnulZ3xPWrVbLjGl6KJyDEZvgJkz66u6weEaqKLjlI7YMkxVOfFKBI6e47rknBZEym0j4wwnvGBZlRHmECKJeya6K0YFMX2VZyKpx76K3QqjLJQts001qWKE7LPNzP6VYMWTl56ae4_nyTX0_z-4m-Aw)
] |
[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/268530/edit).
Closed 2 months ago.
[Improve this question](/posts/268530/edit)
I want an n\*n table that is filled with black or white and the following conditions are satisfied in it:
1. All cells of a 2\*2 square in this table should not be the same color.
2. All black and white cells must be connected horizontally or vertically.
Acceptable examples:
[](https://i.stack.imgur.com/J6A9Q.png)
*Can anyone design a function that takes n as input and generates an acceptable n\*n random table?*
* It is not necessary for the output to be an image, we can use symbols such as 0 and 1 in a two-dimensional array to display the result.
[Answer]
# Python 3, 45 bytes
```
lambda n:["1"*n]+[("10"*n)[:n]]*(n-2)+["0"*n]
```
[Try it online!](https://tio.run/##TY1BCsIwFET3PcXnr/JbFVN3AU@SBkkx1kidlJCNp49xI53VzOPBbJ/yTLjUJeBW/LwGutJUV/@e755gLGvu4QarWJ9bE2vgXK9wHGWw/EOuPlKmSBGUPZagxgNpLaajli1HFBVlN3gCn14pQv0/myB7Rbr6BQ)
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 12 [bytes](https://codegolf.meta.stackexchange.com/q/9428/43319)
Anonymous tacit prefix function, returning a matrix of 0s and 1s.
```
⊢↑1⍪2↓,⍨⍴2|⍳
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HXokdtEw0f9a4yetQ2WedR74pHvVuMah71bv6f9qhtwqPevkddzY961wBFD603Bip91Dc1OMgZSIZ4eAb/TzsEVL/ZDAA "APL (Dyalog Unicode) – Try It Online")
`⍳` **i**ndices 1…n
`2|` division remainder for those, when divided by 2 (gives `[1,0,1,0,…]`)
`⍴` cyclically reshape into an array of the following dimensions:
`,⍨` the self-concatenation of n, i.e. `[n,n]`
`2↓` drop the first two rows
`1⍪` prepend a row of 1s
`↑` take the following number of rows, padding with all-0 rows:
`⊢` n (lit. the identity function applied to n)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
Same output (based on input) on each run:
```
Å1āÉI<.Da)
```
Port of [*@Somebody*'s Python answer](https://codegolf.stackexchange.com/a/268531/52210).
[Try it online](https://tio.run/##yy9OTMpM/f//cKvhkcbDnZ42ei6Jmv//WwIA) or [verify the first ten sizes](https://tio.run/##yy9OTMpM/W8UcnRHmZJnXkFpiZWCkn2lDpeSf2kJjPf/cKvhkcbDnZU2ei6Jmv9tlQKKUktKKnULijLzSlJTFPJhSnW8Du3WObTN/j8A).
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 73 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
Random valid output on each run:
```
1ÝIãIãʒ€ü2ü2εøOO4Ö≠}˜P}ʒD_‚ε©˜ƶ®gäΔ2Fø0δ.ø}2Fø€ü3}®*εεÅsyøÅs«à}}}˜Ùg<}P}Ω
```
[Try it online.](https://tio.run/##yy9OTMpM/f/f8PBcz8OLgejUpEdNaw7vMQKic1sP7/D3Nzk87VHngtrTcwJq9Yr0zk1xiX/UMOvc1kMrT885tu3QuvTDS85NMXI7vMPg3Ba9wztqQUywCca1h9ZpndsKNKS1uPLwDiB5aPXhBbW1QJMOz0y3qQ34/98YAA) (Slightly modified `ʒ...}Ω` to `.r.Δ...` to speed it up, but unfortunately it'll still time out for \$n\geq4\$.)
**Explanation:**
```
Å1 # Push a list of the (implicit) input amount of 1s
ā # Push a list in the range [1,length] (without popping)
É # Check for each whether it's odd: [1,0,1,0,1,0,...]
I< # Push the input-1
.D # Duplicate the [1,0,1,0,1,0,...]-list that many times
a # Change the top list to a list of 0s instead with an is_letter check
) # Wrap all lists on the stack into a list
# (after which this matrix is output implicitly as result)
```
Step 1: Create a list of all possible input by input matrices with `0`s and `1`s:
```
1Ý # Push pair [0,1]
Iã # Take the cartesian power of the input to get all input-sized lists using
# 0s and 1s
Iã # And again, to get all possible matrices
```
Step 2: Filter this list of matrices to keep all where each overlapping 2x2 block contains at least one `1` and at least one `0`:
```
ʒ # Filter this list of matrices by:
€ü2ü2εø # Get all overlapping 2x2 blocks:
€ # Map over each row:
ü2 # Get its overlapping pairs
ü2 # Get the overlapping lists of lists of pairs
ε # Map over each:
ø # Zip/transpose; swapping rows/columns
OO # Sum each inner 2x2 block
4Ö≠ # Check for each sum whether it's NOT divisible by 4
# (aka it's 1, 2, or 3, and NOT 0 or 4)
} # Close the map
˜ # Flatten this matrix of 2x2 block sum checks
P # Check that all are truthy by taking the product
} # Close the filter
```
Step 3: Filter it again to keep those where all matrices where both the `1`s and `0`s form a single island:
```
ʒ # Filter this list of matrices again:
D # Duplicate this matrix
_ # Invert each 0s to 1 and vice-versa in the copy
‚ # Pair the two inverted matrices together
ε # Map over this pair:
© # Store the current matrix in variable `®` (without popping)
˜ # Flatten it to a single list
ƶ # Multiply each value by its 1-based index
®gä # Convert it back to a matrix of size `®`
Δ # Loop until the result no longer changes to flood-fill:
2Fø0δ.ø} # Add a border of 0s around the matrix:
2F } # Loop 2 times:
ø # Zip/transpose; swapping rows/columns
δ # Map over each row:
0 .ø # Add a leading/trailing 0
2Fø€ü3} # Convert it into overlapping 3x3 blocks:
2F } # Loop 2 times again:
ø # Zip/transpose; swapping rows/columns
€ # Map over each inner list:
ü3 # Convert it to a list of overlapping triplets
®* # Multiply each 3x3 block by the value in matrix `®`
# (so the 0s remain 0s)
εεÅsyøÅs«à # Get the largest value from the horizontal/vertical cross of each
# 3x3 block:
εε # Nested map over each 3x3 block:
Ås # Pop and push its middle row
y # Push the 3x3 block again
ø # Zip/transpose; swapping rows/columns
Ås # Pop and push its middle rows as well (the middle column)
« # Merge the middle row and column together to a single list
à # Pop and push its maximum
}} # Close the nested maps
} # Close the changes-loop
˜ # Flatten the flood-filled matrix
Ù # Uniquify this list
g< # Pop and push its length-1
# (only 1 is truthy in 05AB1E, so this checks if two islands remain)
} # Close the map
P # Check that both are truthy, for the regular and inverted matrix
} # Close the filter
Ω # Pop and push a random matrix from this filtered list
# (which is output implicitly as result)
```
] |
[Question]
[
Here is continuation of [this question](https://codegolf.stackexchange.com/q/192715/88163), this time lets compress/generate Mario in colors!
[](https://i.stack.imgur.com/4unZV.png)
Image size is 64x64 (above one is zoomed). The required output is [valid](https://validator.w3.org/nu/#textarea) `<img ...>` tag with exact same image in dataURI form, working on chrome, firefox and safari (and IE4 - joke ;). In snippet below you can find example tag in required form and all needed data.
```
bmpHeader="424d760a00000000000078000000280000004000000040000000010004000000000000000000c40e0000c40e00000000000000000000000000002b81fc00081fcd00085a7200fcfafc005e5e5e001139b90008930b00ababab0000ff000000ff000000fffc00fcffab00abff000000ff000000ff00000000";
bmpPixels="5525552555255525552555255525552555255525552555555055555550555555552555255525552555255525552555255525552555255588504888885048888855055505550555055505550555055505550555055505558850488888504888884404440444044404440444044404440444044404440444885048888850488888440444044404440444044404440444044404440444044488504888885048888844044404440444044404440444044404440444044404448850488888504888884404440111111144440444044404440444044404440444445044444450444444011114441444114400000000000000880000000000000000000000000000000000441441144111100000000000000040800000000000005555555055555550550444441111771100000000000000000480000000000000488888504888885048044444447777770000000000000000000880000000000048888850488888504800777744447777700000000000000000048000000000004888885048888850480077777774477777000000000000000000088000000000488888504888885048007177177744777770000000000000000004080000000048888850488888504800117447777477777011140000000000000048000000004444445044444450440444777777744777711111040000000000000088000000000000000000000000004477117774477771111100100000000000004080000055505555555055555500077714477447741111110410000000000000048000008850488888504888880417774447774770011110011000000000000000088000885048888850488888004777777777471140111041100000000000000004800088504888885048888800011777777744111040011100000000000000000008808850488888504888880001447771177441117700000000000000000000000408885048888850488888000444777144774444447700110000000000000000004844504444445044444400007777744477777744477111400000000000000000000000000650000000000000477777777777774447711000000000000000000000000000055000000000000047117777777774447711400000000000000000000000000006500000000000000014477114774447771170004000000000000000000000000550000000000000004447114447447777147747440400000000000000000000065000000000000000000071447744777717771111040000000000000000100005500001000000000000000047774477771741177111400000000000000051100650001010000000000000000000007777111777411110000000000000015111165111101000000000000000000000777771777444111000000000000015111116511111010000000000000000000077777777447710100000000000001511111651111101000000000000000000000777777744700100000000000000151111165111110100000000000000000000071177774400000000000000000015111116511111010000000000000000000001144777000000000000000000001511111651111101000000000000000000000144477000000000000000000000015111155111101000000000000000000000444000000000000000000000000001511006500110100000000000000000000000000000000000000000000000000010000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003002222000000000000000000000000000000000000000000000000000000000333222222200000000000000000000000000000000000000000000000000000003332222222220000000000000000000000000000000000000000000000000001032222222222330000000000000000000000000000000000000000000000001110223221221233000000000000000000000000000000000000000000000000113333332222200300000000000000000000000000000000000000000000000003333333233320030000000000000000000000000000000000000000000000000033333233323000000000000000000000000000000000000000000000000000000000111111130000000000000000000000000000000000000000000000000000003311113333300000000000000000000000000000000000000000000000000000313311131113000000000000000000000000000000000000000000000000000031311131133300000000000000000000000000000000000000000000000000000333113103330000000000000000000000000000000000000000000000000000022222222211000000000000000000000000000000000000000000000000000000222220011100000000000000000000000000000000000000000000000000000000000001110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" //pixels
dataURI='data:image/bmp,%'+(bmpHeader+bmpPixels).match(/../g).join('%');
msg.innerText=`<img alt src=${dataURI}>`
pic.src = dataURI
```
```
pre {white-space: pre-line;word-break: break-all}
```
```
<img id="pic">
<pre id="msg"></pre>
```
You can use any dataURI image format supported by chrome, firefox and safari (e.g bmp, png, gif etc...). However my proposition is to use dataURI BMP format without base64 which is very simple and which is presented in snippet above - we have there `bmpPixels` string - each character in that string represents one pixel (colors from `0` to `f`) starting from left bottom pixel, line by line. In dataURI we join bmpHeader and bmpPixels and put char `%` between each two characters (hex num) - and thats all. In snippet below I also include bmp+base64 valid example (`img` tag to be valid need to have 'alt' attribute)
```
<img alt src=data:image/bmp;base64,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>
```
You can presents you results in answer using codegolf snippets and include this CSS rule: `img {image-rendering: pixelated;width:256px;height:256px}` to zoom image.
UPDATE
I see that unconsciously I made 2 separate competitions in this question: first for programs (codes written in some programming language which produce result `img` tag), and second for `img` tags which contains results from compression tools. Both are interesting but main competition is for programs. Although I hope that someone shows that hand written program can achieve better results than 'compressed `img` tags' - but may be it is impossible?
[Answer]
## ~~800~~ 791 bytes (for the img tag)
```
img {image-rendering: pixelated;width:256px;height:256px}
```
```
<img alt src=data:;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAG1BMVEUAAAD8gSvNHwhyWgj8+vxeXl65ORELkwirq6tQs3kTAAAB3UlEQVRIx92VwW6jMBCGTUO6PfrfuOWaZbX3Jn6BII3kHsmB9wAJaa455rF3bGEwaeI97KFSx7IQ9sdvzz+WUeqrokButq73WeCplsgBG4vDxmaAwwGHXRaw2GGXASxg7XsuCyAvYI/2+J7Lwdrfdr95rC+AOJUBdH38Vf98nGax8UbWGR/s0QO5Tcr0PlcJlfv824UOtqYjdFo5ftbPbaF1OkSuTwG8nrEGjOPl7RV4OwPpGj/ATFmABeiLxwB7gOOqd4GBR0IOQMVNBCSLtzQLJ+pcNdWA6Ib3Qc3AQAFgoFyc3LbRSXIgJ4BhR+WypihMYdxgmByjV6nd2wg4+AxHYqyqsSg4DkFu0CtgVghfB2AtERVKYp8EEavlYvqgVkZ892XmoRobJKVU5cu1/biGLkDl9aFPydX3ckmAsEeHE3QTN1le1AKUlbfA9QV0oWeBBJBzYNzoRrmYSj0LpIAYxKPjAVATcBKga7sudJ8lT0Csw/XmzpHZkbmHiR6EAtLkhJRayiwq/eJBoK7TLsJZFA1OPPgE0ErgotZA6avwSWANAIwbgXQJMo2ZD3PwwMfkQtvJ78uQIdB9D3zCJRViM8kzbct5uJmIbanF/wPd9m5LgD932z+B+Tz8BfZ10E4lHGFMAAAAAElFTkSuQmCC>
```
Simply ran the image through OptiPNG.
*Thanks to Night2 and Jonathan Frech for helping save 9 bytes.*
[Answer]
# 755 bytes (img tag)
```
img {image-rendering: pixelated;width:256px;height:256px}
```
```
<img alt src=data:;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAG1BMVEUAAAD8gSvNHwhyWgj8+vxeXl65ORELkwirq6tQs3kTAAABwklEQVR4AcRPRwHFIBRjGPj5GKCpAODFv7YOAeTaXLPTZ8hwLNmtoPCBE1RhVRnBWljNCoSGZgQCpOleAD5AoZjug3Sq132+JNIJfoyD//3NXPlCZmS8AjeSZE9GkJz91rADAL7IYLV1GAqiV6C+dqkBtf6dGAZul84i/2GDYbZZ5rOfKmJLojQH7ionk/g41azWwctQ/Jr+LSElawT62gv4vGIUsstOPoGvKxCs8Q6JLwVJXMPfggpUSi+ETTvxSsCkGel8iq/+KVyUpnnacNT46WCnsLEKAmIr+bYcJemgU8pyRjspC0+yb1l0YbU+99shOFTYKbSPhwVXhb618sNC/XYVholzIVIbRVIGO/jmQtYzC0WY9hmyRvx4LN+PekWYJBHpEtrAx70TXAXHBWlOx8DdmhAn0eVrQArpHOgEe1f23XcAMZ0DvUBBu2sD7ClcinBbbrd6FilVob2ohw1gd+3Sinw0sAL5LGG2aRKL0BpU6/H8F2aqv6CuwS+Bw8DdRiGS1DDwWwCEYWAQjHnOM5KdDSq1ws9ZQGYm2DUYYWQAwP8D0sgQkR7AXEyIiAvKFYSyYoVIClSxQcIK4OkBAPZ10E6zEPFIAAAAAElFTkSuQmCC>
```
Ran Lewis's image through 200 iterations of [zopflipng](https://github.com/google/zopfli) with all possible filter combinations enabled.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 1447 ~~1565~~ bytes
Too much time on this one already. :)
```
N="1q/4xt/5E3S9n/3YWDwhfwblbew5x/4P/5Cw
1/va
1/oEw.Q/16p7/2X4
1s/2Z.Wc.Wc.Wc8.Z2/1bfhM.QLb/108dQ.Qc/2Kw
1/2V.W/b5/10/10
1/dO/10/10/10/40
1/ap/88w
1@4g/5S.Qx/2y.Qx
23
1/1k
3D4
2/5_/45wu2u2s/24/2cx41id1iv1/2d1r41q/5p
1/1e/3K11r5wt12/2r8w1p61u11vu2u4tAwT8wqE1xs4a3j9.R.R.Yde.R.Ys3/6kw/1z11u1w2uwzww
1/qK
1/sK_2v
1/5q2u2/36/1p/4w3B/3_
1/hLwwwwz
1/hiwwwww
1/8r/2u.Qz/3Cw2v
8_
1/pd/21w/3_
1/qI
1/oG1v11v111s1111s3v1/3@111t1
1/rI
2/1V.Wc.W
3e
3W
5/se.Q
1/tGw12w
1/pG.Q/1w2
1/p9wCwq11u112s12@31tAs4
6/1f
7i4/5N/44/1lx/1A_y/1y/3W
1/5X2/5CY/45y
10
2/3o.W2a.W2a.W2a251.Z221.T.T422qw1v11w1.QO11.T22w/12/13sw3.Te.T.T64wwvr326o2w/16vwwZv
3/7Z@zwu2u2r5/24o8oy5r36V/35w
1/2N4.S/1W44o44o44o44o44j/1D4.Sp
51
3/[[email protected]](/cdn-cgi/l/email-protection)/40
1/gMw3wwwwwt3t
4/1U.W21.T.T1.W2a.W2/3111.T2/3U.T.T
5/13
4/1a11
i/7v.Qw/1_/45/3y/1u
1/8p/17w/2swDwW/10FZ
1/14
2/7Y@3www2/1_@/14/35
22
1/6tv11r.R1.R221t21r113r23rw3t111u11u6q34o.Y1r11111s1113t3v12r212r21v13s12t1112s11v1w
1a
8/68wxwx/22wxwx
1/X
7/2L3.U.U.YM/19.R.R.R.R.YS/143.U.U.Y
b/1j
o/1m11g2
e/1g
bC4
9/10
J/17
2Ya2s2
3/1r444444"
R=(/11 .Yr .X.X 211 .V.V .Yo3 .Z.Z 4s4s 131 22222)
for x in {Q..Z};{ N=${N//.$x/${R[i]}};i=$[i+1]; }
U=($N)
for((j=0;$j<62;j++)){
for((i=0;$i<${#U[j]};i++)){ c=${U[j]:i:1};[ "$c" = '/' ]&&c=${U[j]:i+1:2}&&i=$[i+2];T[$j]+=" $[64#$c]"; }
read p x t<<<${T[j]}
P=$[P+p]
S[$x]=$P
for n in $t;{ x=$[x+n];S[$x]=$P; }
}
echo "<img alt src=data:image,`for((j=0;$j<4096;j++)){ printf %%%02x ${S[j]}; }`>"
```
[Try it online!](https://tio.run/##TVP/U@I6EP89f0WGq54Ob7LuJi0o8gZPfc49lRNFERjGK1/EcirQFlJl@Nt9m@LNuzbdJrvZ7H4@u@mHydPHR71awDmYLAX/VN/sv4Jut07s06PtP/dH1s/AXIF/bAXCMmQxPbWqARjMSkD3RmAC1FGtwWaUVYcA@49Pl6px0QfcKw8bqjEAOnf@dKda0PdZzYPXwx@bqRvGKcIZlMu8s2bG4N@oRgb0xlKQZiP@EvrECAL/AYxvF7Qgjm2ABpnBaIjRkiMMMTaMxp85hxHoc8TYtykSUFy2OAtwgbhkX5Me2WbZzk8xS0yoJ/vqmt/2cORkoiH4ZQHfkbdbWth36/Kfn7NIzh9oyX9/zgmADgBnYKz@BvqBtU8Xlp93N4vczLmVY6CFaryDPrbsWnb7ZkMgtBuf@XdH6xku0Q1M0AnNaHSNZymyNf7OuPEuJ1nokdAt4UMyUg22pWcWycWZnbnCWHLTfXts5y57pASppjE9SozgZB9FKTLg18EYwOcM8OjhDfAN@ETGdM/sHreZ3jfBFWJ4U9Wi8PdHPnJ9CVVTNQ3R3Lp8LarGD2QdETPGWerEatUcuU2BsXYZawqmzhYsre0shYZSp/ae1y/2uYDT8vTNj3VwB9rPu6Ru1A1gy5jpH2MCeML6mfCRT6Axz9V9LZetXC5zuu2mkcaXVufLVKeCgd5y@nna@IkFNOY5g751amYTtdsYIooISkvV4IRdn4FmehauijPAkgVK7Iltccf@03Et5vqx1K65YAz9ocYahiHIFSFImZ5YXaO6ZtJSwhhRx6Rjq1PMa7MI5tpMVdtZPiuvU648xZR/SyYTyW3mKvKK6QlFGYKyzSzfDXI/DnQv@C5eaHXLb/sScNPLeT8zkebTIPg@TsQU8AVxTGIEOBb9YyP23WX8l8EJaoeUENPLlyh/CuK6ugOIUrVjqe7VvSS3uFN3rJlqqTqqI01iEokaJblnVzxOY5nJ6FWuGkp11pWVrFe9VR1AeRl4q@tu1FuvK1HV60ZF7FXkWtxWd7x67rizM6nuVbzJYUCVSbG4u7vaaCOnjQ691Zfb7qTH3rlNDvhgpziIDnBd6cqCNyjIqvwKX2Vve/t/axEPaL29vYlJvUqz6016xWpBet3AfPEGvYJLIx6FQznj3NPDQw7VdJHEFftcFWc9cdP1sl7Vu8rxvTp8XsrYMrZnxdde5bfdnbQWo8HTVBYOo5exDJ9TmcSD6jBMw4PoJRyP/vr5J1Sztx98gpWzOHpNH@XW1tYeZdJb3eRo5frn34WPj/8A "Bash – Try It Online")
```
img {width:256px;height:256px}
```
```
<img alt src=data:image,%42%4d%76%0a%00%00%00%00%00%00%78%00%00%00%28%00%00%00%40%00%00%00%40%00%00%00%01%00%04%00%00%00%00%00%00%00%00%00%c4%0e%00%00%c4%0e%00%00%00%00%00%00%00%00%00%00%00%00%00%00%2b%81%fc%00%08%1f%cd%00%08%5a%72%00%fc%fa%fc%00%5e%5e%5e%00%11%39%b9%00%08%93%0b%00%ab%ab%ab%00%00%ff%00%00%00%ff%00%00%00%ff%fc%00%fc%ff%ab%00%ab%ff%00%00%00%ff%00%00%00%ff%00%00%00%00%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%55%50%55%55%55%50%55%55%55%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%25%55%88%00%48%88%88%50%48%88%88%55%48%55%05%55%05%55%05%55%05%55%05%55%05%55%05%55%05%55%05%55%05%55%88%00%00%88%88%50%48%88%88%50%48%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%88%00%00%88%88%50%48%88%88%50%48%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%88%00%00%88%88%50%48%88%88%50%48%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%88%00%00%88%88%50%48%88%88%50%04%44%01%11%11%11%44%44%04%44%04%44%04%44%04%44%04%44%04%44%04%44%44%00%44%44%44%50%44%44%44%01%11%14%44%14%44%11%44%00%00%00%00%00%00%00%88%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%44%14%41%14%41%11%10%00%00%00%00%00%00%00%40%80%00%00%00%00%00%00%55%55%55%50%55%55%55%50%55%04%44%50%11%11%77%11%00%00%00%00%00%00%00%00%04%80%00%00%00%00%00%00%48%88%88%00%48%88%88%50%48%04%44%50%44%77%77%77%00%00%00%00%00%00%00%00%00%08%80%00%00%00%00%00%48%88%88%00%48%88%88%50%48%00%77%77%44%44%77%77%70%00%00%00%00%00%00%00%00%04%80%00%00%00%00%00%48%88%88%00%48%88%88%50%48%00%77%77%77%74%47%77%77%00%00%00%00%00%00%00%00%00%08%80%00%00%00%00%48%88%88%00%48%88%88%50%48%00%71%77%17%77%44%77%77%70%00%00%00%00%00%00%00%00%04%08%00%00%00%00%48%88%88%00%48%88%88%50%48%00%11%74%47%77%74%77%77%70%11%14%00%00%00%00%00%00%00%48%00%00%00%00%44%44%44%00%44%44%44%50%44%04%44%77%77%77%74%47%77%71%11%11%04%00%00%00%00%00%00%00%88%00%00%00%00%00%00%00%00%00%00%00%00%00%44%77%11%77%74%47%77%71%11%11%00%10%00%00%00%00%00%00%40%80%00%00%55%50%55%55%55%50%55%55%55%50%07%77%14%47%74%47%74%11%11%11%04%10%00%00%00%00%00%00%04%80%00%00%88%00%48%88%88%50%48%88%88%50%48%77%44%47%77%47%70%01%11%10%01%10%00%00%00%00%00%00%00%08%80%00%88%00%00%88%88%50%48%88%88%50%48%77%77%77%77%47%11%40%11%10%41%10%00%00%00%00%00%00%00%04%80%00%88%00%00%88%88%50%48%88%88%50%48%17%77%77%77%44%11%10%40%01%11%00%00%00%00%00%00%00%00%00%08%80%88%00%00%88%88%50%48%88%88%50%48%44%77%71%17%74%41%11%77%00%00%00%00%00%00%00%00%00%00%00%04%08%88%00%00%88%88%50%48%88%88%50%04%44%77%71%44%77%44%44%44%77%00%11%00%00%00%00%00%00%00%00%00%48%44%00%44%44%44%50%44%44%44%00%00%77%77%74%44%77%77%77%44%47%71%11%40%00%00%00%00%00%00%00%00%00%00%00%00%06%50%00%00%00%00%00%00%47%77%77%77%77%77%77%44%47%71%10%00%00%00%00%00%00%00%00%00%00%00%00%00%05%50%00%00%00%00%00%00%47%11%77%77%77%77%74%44%77%11%40%00%00%00%00%00%00%00%00%00%00%00%00%00%06%50%00%00%00%00%00%00%00%14%47%71%14%77%44%47%77%11%70%00%40%00%00%00%00%00%00%00%00%00%00%00%05%50%00%00%00%00%00%00%00%44%47%11%44%47%44%77%77%14%77%47%44%04%00%00%00%00%00%00%00%00%00%00%06%50%00%00%00%00%00%00%00%00%00%71%44%77%44%77%77%17%77%11%11%04%00%00%00%00%00%00%00%00%10%00%05%50%00%01%00%00%00%00%00%00%00%00%47%77%44%77%77%17%41%17%71%11%40%00%00%00%00%00%00%00%51%10%06%50%00%10%10%00%00%00%00%00%00%00%00%00%00%77%77%11%17%77%41%11%10%00%00%00%00%00%00%01%51%11%16%51%11%10%10%00%00%00%00%00%00%00%00%00%00%77%77%71%77%74%44%11%10%00%00%00%00%00%00%15%11%11%16%51%11%11%01%00%00%00%00%00%00%00%00%00%00%77%77%77%77%44%77%10%10%00%00%00%00%00%00%15%11%11%16%51%11%11%01%00%00%00%00%00%00%00%00%00%00%07%77%77%77%44%70%01%00%00%00%00%00%00%00%15%11%11%16%51%11%11%01%00%00%00%00%00%00%00%00%00%00%07%11%77%77%44%00%00%00%00%00%00%00%00%00%15%11%11%16%51%11%11%01%00%00%00%00%00%00%00%00%00%00%01%14%47%77%00%00%00%00%00%00%00%00%00%00%15%11%11%16%51%11%11%01%00%00%00%00%00%00%00%00%00%00%01%44%47%70%00%00%00%00%00%00%00%00%00%00%01%51%11%15%51%11%10%10%00%00%00%00%00%00%00%00%00%00%44%40%00%00%00%00%00%00%00%00%00%00%00%00%01%51%10%06%50%01%10%10%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%10%00%00%00%00%01%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%03%00%22%22%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%03%33%22%22%22%20%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%33%32%22%22%22%22%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%01%03%22%22%22%22%22%33%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%11%10%22%32%21%22%12%33%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%11%33%33%33%22%22%20%03%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%03%33%33%33%23%33%20%03%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%33%33%32%33%32%30%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%11%11%11%13%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%33%11%11%33%33%30%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%31%33%11%13%11%13%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%31%31%11%31%13%33%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%03%33%11%31%03%33%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%02%22%22%22%22%11%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%22%22%20%01%11%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%01%11%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00>
```
] |
[Question]
[
**This question already has answers here**:
[Interpret brainfuck](/questions/84/interpret-brainfuck)
(78 answers)
[Make a +-#$%! interpreter](/questions/122343/make-a-interpreter)
(13 answers)
Closed 6 years ago.
A few month back, I made a language called [`;#`](https://codegolf.stackexchange.com/q/121921/66833) (Semicolon Hash) and it started a little bit of a craze (it even got its own tag, as you can see). But, as with everything, the craze died down, and questions related to it stopped being posted.
However, a few people were annoyed at the lack of capability of `;#` and this lead to [someone](https://codegolf.stackexchange.com/users/31957/conor-obrien) creating a [Turing complete version](https://github.com/ConorOBrien-Foxx/shp). Eventually, I decided to create `;#` 2.0 with an extended set of commands:
```
; - Increment the accumulator
# - Modulo the accumulator by 127, output as ASCII character and reset the accumulator to 0
: - Open a while loop
) - Close a while loop. You can assume that all loops will be closed.
* - Take a byte of input, and add it to the accumulator. Input is recycled, so if the end of the input is reached, it wraps around to the start.
```
FYI: `;#*:)` still isn't Turing complete
For example, a cat program would be
```
*:#*)
* - Take a byte of input
: ) - While the input character is not a null byte...
# - Print as character
* - Take a byte of input
```
For this, the input must be terminated with a null byte, otherwise the program will repeat the input until the heat death of the universe.
and to add two numbers (input and output as char codes):
```
**#
* - Take input (e.g. \x02); A=2
* - Take input (e.g. \x03); A=5
# - Output A as character (\x05)
```
Your task is to interpret `;#*:)`. Your program/function will be given 2 inputs, the program and the program's input, and you have to interpret the given program.
A few rules:
1) Your program may not halt termination due to an error unless 2) happens. Output to STDERR is allowed, just so long as it doesn't affect the program's execution.
2) If the second input is empty (a `;#*:)` program with no input) and `*` occurs in the code, you don't have to handle the error and can cause any kind of behaviour you want; summon [Cthulhu](https://github.com/Mr-Xcoder/Cthulhu), make Dennis lose his rep, anything you want.
3) All characters that aren't `;#*:)` are ignored and have no effect on anything.
Nested loops **can** happen, and all loops will be closed, so `;:*:#*);)` is valid code
**This is a code golf, so shortest code wins.**
Some tests to check your program against:
```
program, input (as ASCII characters; \xxx is a byte literal) => output
*#*:#*), "1" => 11111111...
**#, "12" => c
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#, "abc" => Hello, World!
*#, "" => undefined
Hello, World!, "" => (nothing)
*:#*):;#*)*#, "Hello,\x00World!" => Hello,W
*:#*), "Testing\x00" => Testing
*:#*), "Testing" => TestingTestingTestingTesting...
;:*:#*);*), "123\x00" => 223d3d3d...
```
And, to help you even more, [this](https://tio.run/##xVRNT4NAEL3zKybbmLJITakHEypHD1568labhsAim9BdMl1i@@vrAguMVi8mRg58zMeb9x4D9dmUWt1fLowxWM@CGKQyAmsU9gw26Hm5KKBKj2YjVS5O/tGgVG8hZGWKIWx47IE9ZAF94i7TjTJ@m@XwCJs@3R4WskEFi6iLFLYshwSW7glBWkw7HYRqDgJTI9yobRwvol0IEZ@w7LgMkqQjMUUn3NsEIlrspiWUD@FUCeWGcViA9D7T7RwoJP6fBX@n/Fut2Kh9pnPh16jfMD2EllPdmD0hU2ld73NRm9IJSLPM3fW1nVNDxF3fS1kJeMFG9FxaDTblpmzlbvCxTyTA1mxg3eKP2mjJbCypLTvjC5UnWYm@bbiJVg@cE4DBa9ofjP02SnVOfhk8U/McFY25T@u3RPiOj/XilFmb4LkNPyHqT2/t2qvfDSmkSqvq/BP0aNxX9fN4PvSQN0p2yNYqbVo2ZAUtVfJDGJeEcRYSGO5dTeNz4vUVJv3EJtD4C6hztTqKqZtwX4w70sm4jLvM1nEQzwK@DlqaLFrdv56WS8YvHw) is an ungolfed reference implementation in Python. In this version, I have decided to make the `*` on empty input be ignored.
Good luck!
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~147~~ 144 bytes
Saved 3 bytes thanks to m-chrzan!
```
z=STDIN.read
eval ARGV[i=a=0].gsub(/./){|e|"#{{?;=>"a+=1",?#=>"putc(a%127);a=0",?:=>"while a>0",?)=>"end",?*=>"a+=z[i%=z.size].ord;i+=1"}[e]};"}
```
[Try it online!](https://tio.run/##JYzNCoJAFEb3PYWMCGoxZpvAYZQgiDYtKtqIi6sz1gWx8Kdo1GefRtqd78D5mj7/aq345bo/nmgjQSzkGyprdz7cUuTA1xm9t33uBjTwhlGOxB6GhPGYwJKHZJXYBl99V7jghJutx0xhbGTs54GVtCCet2e2rIUh/5@qFB2uaItKZvTZCIbz3ZTKbGJk0hrrEmvspFVA1y60H9m@B6L8AQ "Ruby – Try It Online")
Program is taken from first command line argument.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~261~~ 253 bytes
*-8 bytes thanks to [@Mr.Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder)*
```
p,i=eval(input());a=k=c=z=0;j=[];m={}
for y in p:
if':'==y:j+=[z]
if')'==y:b=j.pop();m[b]=z;m[z]=b
z+=1
while p[c:]:
y=p[c];a+=';'==y
if'*'==y:a+=ord(i[k%len(i)]);k+=1
if'#'==y:print(end=chr(a%127));a=0
if y in':)':c=[c,m[c]][(a>0)>(')'<y)]
c+=1
```
[Try it online!](https://tio.run/##NY7dboQgEIXvfQqi2QBqG3f3ogl0fBHCBbJuZf0jxG2rTZ/djiS9GQ6HOR/Hr0s3T9c9I54I4sP8EcyYZMThzU3@uaA2qI21z/E5mGUO6PT/rzhv7Tc6IzpUUPJSE8ppeYyoBd196aD9NAOLCca5NNCDhQ0q@QCl5Qg/v8l9DmRFHPEiIe6OQYBVPApQm44Gj0YDj1c/e8blqBoNGx6bhiYhWwHn5KtzQ0u8skIjZQVUWpoCqDzCEZNHDHpzuDGn@tPQTsxxzWV/EI6VLK744KaFtdMNbBeYOZ0vb7F6dezEqlRwKiwoW474j1bM1BWvGTZ9XzmWtgjc91SKXGQ5lzlPS5KeL9e0OIgV/wM "Python 3 – Try It Online")
# [Python 3](https://docs.python.org/3/), 253 bytes
Same length using `exec`
```
p,i=eval(input());a=k=c=z=0;j=[];m={}
for y in p:
if':'==y:j+=[z]
if')'==y:b=j.pop();m[b]=z;m[z]=b
z+=1
while p[c:]:y=p[c];exec('a+=1 print(end=chr(a%127));a=0 a+=ord(i[k%len(i)]);k+=1 c=[c,m[c]][a<1] c=[c,m[c]][a>0] 1'.split()[';#*:)'.find(y)]);c+=1
```
[Try it online!](https://tio.run/##VVDLboMwELzzFStQZJvQCJJDJbubH7F8cBxSHF4WJW2g6rfTBamHXnZnZzSzXodprPrutCQQQEIY@vfBtlECnibfhcdI2BK2zj3aR2PHfiCm/lOpXssnMS0xTDJ4OQMTLFvLhiVbQuax/LQN3xxcCGWxRocz5uqO2qgWv3@iWz/ARHEQZAT@RkbESd73qGezEWIjLng/hD5woVp9MThTmw1eIpj3WERflW9KCNpJIyekblT5LB1nllS6zncjL7srumrgdlccX7fH5EByP1y51/WuKTvuhRGqXi0OtctayjHavhXm33zODRTs8BEaT1dpppJUCna40ZfwaU1wlLAssZKpTFKhUhFnEBfHU7xf9@fiFw "Python 3 – Try It Online")
] |
[Question]
[
## INTRO
Let's say you write a passage and you are close to the end of the line wanting to write down a large word. In most languages, you just leave some blank and move to the next line, like a sir.
>
> Example - English:
>
>
>
blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah this man is unaccountable
But if you are (un)lucky enough to be Greek, when you are close to terminate a line, you cannot just move to the next one. Everything must look nice and in balance, so you SEPARATE the word
>
> Example - Greek:
>
>
>
μπλα μπλα μπλα μπλα μπλα μπλα μπλα μπλα μπλα μπλα μπλα μπλα αυτός ο άνδρας είναι ανεξή-
γητος
Of course this separation is not done randomly, but instead there is a complicated set of rules, as to how & when to separate, which is actually an entire learning chapter back in primary school that every kid hates.
## OBJECTIVE
You are given a greek word (just a string of greek letters). You need to do a greek syllabication, i.e. separate the greek word in syllabes, according to the set of rules given below, so that the user will have the option to separate the word in the end of the line correctly.
Examples:
1) αγαπη (love) = α-γα-πη
2) ακροπολη (acropolis) = α-κρο-πο-λη
3) βασικα (basically) = βα-σι-κα
## ALPHABET & SIMPLIFIED RULES
**consonants:** β,γ,δ,ζ,θ,κ,λ,μ,ν,ξ,π,ρ,σ,τ,φ,χ,ψ
**vowels:** α,ε,η,ι,ο,υ,ω
**rule 0)** Every vowel defines a different syllable, unless rule 4
**rule 1)** When there is consonant between two vowels, it goes with the second vowel
(ex. γ --> α-**γ**α-πη)
**rule 2)** When there are two consonants between two vowels, they go with the second vowel, if there is a greek word starting from these two consonants (we assume that that's always the case in our exercise)
(ex. βλ --> βι-**βλ**ι-ο)
**rule 3)** When we have 3 consonants between two vowels-->same as rule 2
**rule 4)** Following configurations are considered as "one letter" and are never separated: ει, οι, υι, αι, ου, μπ, ντ, γκ, τσ, τζ
(ex. α-**γκυ**-ρα)
**rule 5)** Always separate same consonants
(ex. α**λ-λ**η)
## YOUR TASK
Your code should take as input string (or some other format you wish) a greek word and return the same word, with dashes in between, determining the points where the word can be separated, i.e. do a greek syllabication.
```
TestCases:
[πολη (city)] --> [πο-λη]
[τρεχω (run)] --> [τρε-χω]
[αναβαση (climbing)] --> [α-να-βα-ση]
[οαση (oasis)] --> [ο-α-ση]
[ουρα (tail)] --> [ου-ρα]
[μπαινω (enter)] --> [μπαι-νω]
[εχθροι (enemies)] --> [ε-χθροι]
[ελλαδα (greece)] --> [ελ-λα-δα]
[τυροπιτα (cheese pie)] --> [τυ-ρο-πι-τα]
[αρρωστη (sick)] --> [αρ-ρω-στη]
```
Shortest code wins, but every effort is appreciated :)
[Answer]
# [Haskell](https://www.haskell.org/), 222 201 bytes
```
s""=[]
s x|c?"ειοιυιαιου"=(a++c):s d|h:e:f:g<-b,e==f=(a++[h,e]):s(f:g)|e:f<-b=(a++[e]):s f|2>1=[a]where(a,b)=break(`elem`"αεηιουω")x;(c,d)=splitAt 2 b
i?(x:y:z)=i==[x,y]||i?z
i?""=1>2
```
[Try it online!](https://tio.run/##hVLNattAEL7rKYY97WL1EB/VbkwugdCUHHoUopHldSQsq8ZSiRJ0qIlDyeM41CTGNX6D3UdyZkdSq4TSSojd@X7mZ1dxmE9Umh4OOWPSD5wcyioaML3WG73XG3OP68ruzT2TPOz1IuHlMKpiT3lj7@rDu6GrpBwT5ceuCpDmSIgKeWRrgmAYV/3jI@mHwXWs5oqH7lDI4VyFE36pUjW9ZFhprZ/qauaBifI9j9yRkPksTYqTAvowBCcZ8NK78W6FTKT0S/cmqKpkcIs4TnB03D8UKi9y8Dzw@edinmRXLvj1JhCBU7MSHMDHB87Mdxx0q58YyijADSMgECRyrWhpFnptfmBXJKPQCgnqCHGEHX6PemXumpx6RRl3zfpYr0R3jfuuBZsg319keDQLSuFTQLks0BX9wjnsre2aflvAZt29aRin0s@YYW9pq13bsn@wV1o8ly0m@tk2gIDNuaVeCX59aLbXPdbemGVjsaAtsKAZLWWX5ZsBVmaB74O5Q6Y9RbMgnx2JNURjCcBxpmGS2Us/uwAu6kjCNJx9@gJRrKIJ0MU7QP@eddUoT7LZt8IFVc5UVKiRQFcyhhwIByl/M1TpH08RqwzQg7/aeYYzXHz0gEGvV2cS/7OrNFdd@@nJ2Xk3gd2wOs7jr9fA277ctlkhnMML "Haskell – Try It Online")
[Answer]
# Python, 183 bytes
```
def f(s,r=''):
for p,c in zip(' '+s,s):
if p in'αεηιουω'and(p+c)not in 'ει,οι,υι,αι,ου,μπ,ντ,γκ,τσ,τζ'or p==c:yield r+p;r=''
elif p>' ':r+=p
yield r+c
```
[Try it online!](https://tio.run/##NVBLTsNADN3nFFY2M1EGNuyC0osgFlE@YlA1GaVZpKxaNRHqcQIqVYGqN7CPFGzSLsaaZz/7Pduv25faPUxTUVZQ6ZVpUqWiJICqbsCbHKyDN@u1AhWvzEoqYCvwnFc44gGPeMILDbRXmSu0j/PI1a10KS6eDF440CC/8R/SYPCXNgbP1Bv8xG9DPe044JcSyTTNk7UtlwU0sX8UN6xYLkVzwSaSJk59ADdGPmWQwhNTAELasNoPHkMDM@5piwd6p31oZgZ7OPP7wJF2My/kliu4UmSZLY63IWJWrLNfGfMcBHKZTjbM5Bi@sa7VnQGVLhTHO3X/WlunK91FUTT9AQ)
[Answer]
# Bash + sed, ~~188~~ 187 bytes
```
sed -re $(echo 's/([^@\1/\1-\1/g;s/[εουα]ι|ου|μπ|ντ|γκ|τσ|τζ|./-&/g;s/!(!)?(!)?([@/\1\3\5\6/g;s/-([^@(-|$)/\1/g;s/-+/-/g;s/.//'|sed 's/!/([^-@-/g;s/@/αεηιουω])/g')
```
[Try it online!](https://tio.run/##NU9LTsMwEN3nFIlUkUSVa1UINizIPeIi8YnaHVKz9aJRiqocx0AJplS5wZsjhecAsmY04/fx88N9vRnHunqK1baKZ1n1uHmO01pn5V1hltosFfv6ptYljhjkBW4Fb8Nk8S07i7PsLd7wZWUvLRs@7EKri0mTZEl@O1VZ0MpcmitzPSEq@GfKznL956/mWk3DQuvUhkBMkYQcqvgFCg3HED18eF66Va7XaT6OssOAE/qICRoc5SBdROaZ9QonLRES/gcqG7gohCfBMz/ZFOGT9wM8F5qdiL2TRsvAH0j2/Bt1ThqeTlqu/Q8 "Bash – Try It Online")
Uses a sed program compressed with... sed. The actual sed program looks like this:
```
# replace consecutive consonants: αρρωστη -> αρ-ρωστη
s/([^αεηιουω])\1/\1-\1/g
# separate "letters": αρ-ρωστη -> -α-ρ---ρ-ω-σ-τ-η
s/[εουα]ι|ου|μπ|ντ|γκ|τσ|τζ|./-&/g
# attach preceding consonants to vowels: -α-ρ---ρ-ω-σ-τ-η -> -α-ρ---ρω-στη
s/([^-αεηιουω])-(([^-αεηιουω])-)?(([^-αεηιουω])-)?([αεηιουω])/\1\3\5\6/g
# attach lone consonants to previous vowel: -α-ρ---ρω-στη -> -αρ--ρω-στη
s/-([^αεηιουω])(-|$)/\1/g
# remove extra dashes: -αρ--ρω-στη -> -αρ-ρω-στη
s/-+/-/g
# remove initial dash: -αρ-ρω-στη -> αρ-ρω-στη
s/.//
```
] |
[Question]
[
I'm golfing a program to sum two numbers in C++.
Example:
```
10 3
13
```
I found out that this problem can be solved in 54 symbols (without spaces and so on) using C++.
My code (63 symbols):
```
#include <iostream>
main() {
int a, b;
std::cin >> a >> b;
std::cout << a + b;
}
```
I have no idea how to make my program shorter. Can you help me, please?
[Answer]
# 48 bytes
How about...
```
#include<cstdlib>
main(){system("tr \\ +|bc");}
```
...not using C++?
---
* The call to `system` runs commands on your shell (`<cstdlib>` declares `system`).
* `tr \\ +` executes the command [`tr`](https://linux.die.net/man/1/tr), translating spaces to `+` (so the input`34 45` becomes `34+45`).
* `|` [pipes](http://tldp.org/HOWTO/Bash-Prog-Intro-HOWTO-4.html) `tr`'s STDOUT into [`bc`](https://linux.die.net/man/1/bc)'s STDIN.
* `bc` performs equations in STDIN and prints the result to STDOUT.
] |
[Question]
[
# Your Challenge
You must write a program/function etc. that takes a domain name of a StackExchange site and outputs the domain for the meta version of the site passed to it. Examples:
```
stackoverflow.com => meta.stackoverflow.com
codegolf.stackexchange.com => codegolf.meta.stackexchange.com
mathoverflow.net => meta.mathoverflow.net
codereview.stackexchange.com => codereview.meta.stackexchange.com
```
Note: Subdomains are added to `meta.stackexchange.com`. Separate domains have `meta.` prepended. You don't need to worry about `stackexchange.com` or `meta.stackexchange.com` passed.
# Shortest answer in bytes wins!
[Answer]
# Retina, 17
```
\w+\.\w+$
meta.$&
```
[Try it online](https://tio.run/nexus/retina#U9VwT/gfU64dowckVLhyU0sS9VTU/v8vLklMzs4vSy1Ky8kv10vOz@VKzk9JTc/PSdMDS6VWJGck5qWngqVyE0sy4GrzUkvAaotSyzJTyzFVAwA).
[Answer]
# GNU Sed, 20
Score includes +1 for use of `-r`.
```
s/\w+\.\w+$/meta.&/
```
[Try it online](https://tio.run/nexus/sed#Zco7DoAgEADR3nMYGyNciIbg8onAGtiAp3c1FDY208zjKlVflXgzywSkxSKZK2lzYINiI3ZhME0Gd3AYrRgLLuN1djBW0uQ/m4GGLdAC9L@@8aSAufJWHg).
[Answer]
# JavaScript (ES6), ~~41~~ ~~40~~ ~~34~~ 32 bytes
```
s=>s.replace(/\w+\.\w+$/,'meta.$&')
```
```
<input id=a oninput="b.innerText=a.value.replace(/\w+\.\w+$/,'meta.$&')"/>
<p id=b />
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), ~~21~~ 20 bytes
```
aR`\w+.\w+$``meta.&`
```
[Try it online!](https://tio.run/nexus/pip#@58YlBBTrq0HxCoJCbmpJYl6agn///9Pzk9JTc/PSdMrLklMzk6tSM5IzEtP1UvOzwUA "Pip – TIO Nexus")
Matches the last two runs of word characters (separated by some other character), to which it prepends `meta.`.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~57~~ 54 bytes
```
l=input().split(".");l[:-2]+=["meta"];print".".join(l)
```
[Try it online!](https://tio.run/nexus/python2#HcnBDoIwDADQu19hetpi7MEjhL/whhyWWaBa1mUU8e@n4V3fPrPQ@V42ah5VOk55M@dxzcLmAMG30jfX23DpeljIAgxtLpzsX/hSTk58rbBaiG/9UBlFd4y6wAmiPmlSGfFI@sY5pImO/AE "Python 2 – TIO Nexus")
Split on periods, insert `"meta"` before the second item from the end, join the list again on periods and print.
[Answer]
# JS (ES6), 59 bytes
```
m="meta.",a=>a.split(".").length-2?a.replace(/\./,"."+m):m+a
```
If the string passed to the function expression has more than 1 `.` in it, a `.meta.` is inserted in the first `.`. Otherwise, `meta.` is appended to that string.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~22~~ 19 bytes
```
ṣ”.ṙ-2;“£2v»W¤ṙ2j”.
```
**[Try it online!](https://tio.run/nexus/jelly#@/9w5@JHDXP1Hu6cqWtk/ahhzqHFRmWHdocfWgIUMcoCSf3//z85PyU1PT8nTa@4JDE5O7UiOSMxLz1VLzk/FwA "Jelly – TIO Nexus")**
### How?
```
ṣ”.ṙ-2;“£2v»W¤ṙ2j”. - Main link: domain string
ṣ”. - split at occurrences of '.'
ṙ-2 - rotate right by -2
¤ - nilad followed by link(s) as a nilad
“£2v» - dictionary lookup of "meta"
W - wrap in a list
; - concatenate
r2 - rotate right by 2
j”. - join with '.'s
```
[Answer]
# PHP, 48 Bytes
```
echo preg_filter("#\w+\.\w+$#","meta.$0",$argn);
```
but we should better do it like this
```
echo strstr($argn,"meta.")?$argn:preg_filter("#\w+\.\w+$#","meta.$0",$argn);
```
] |
[Question]
[
# Code-Bowling Quine Challenge
You must bowl a quine following the rules of code bowling and quines but the source code must be in the shape of a **rectangle** (details specified below)
---
# Quine
Quines returned must be returned via the ways defined in [the standard I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
---
# Rules
### Code-Bowling Rules
1. **Character : Byte Ratio** In Code-Bowling a character-count is
preferred over a byte-count. The obvious reasoning for this is that
multi-byte unicode characters (e.g. üÅ¥) can be used in place of
single-byte unicode characters to fluff up byte count and will make
bowling more about who renames the most variables with high-byte
unicode characters rather than who most strategically creates
meaningful complex code. (See Useful tools section at end for
character-counting widget)
2. **Variable/Function/Object Names** All variable names (or object pointers, function names, etc) should be 1 character long. The only
acceptable time to use 2-character variables names is after all
possible 1-character variables have been used. The only acceptable
time to use 3-character variables names is after all possible
2-character variables have been used. Etc.
3. **Non-simplified Arithmetic** All arithmetic should be in simplified form unless there is a justifiable reason for doing otherwise (e.g.
circumventing penalties defined in the scoring system of the
challenge (In which case you still must use the smallest possible
alternative form)). Finding the simplified form of any equation (as
well as a list of small alternative forms) is easy to do using
Wolfram|Alpha. (See Useful tools section at end)
4. **Un-used Code** All code must be used. Meaning the program must fail to always properly complete the task if any individual character (or
varying set(s) of characters) is/are removed. Naturally, a subset of
the program should not be able complete the task on its own without
the rest of the program.
5. **Line-breaks and White-space** Unless necessary for code function or otherwise specified by the challenge, all line-breaks and
white-space should be removed from code before scoring by counting
characters.
6. **Comments** Comments are not permitted towards character-count, unless somehow utilized by your program/function.
### Rectangle Rules
Your code must be in the shape of a rectangle, i.e. every line has the same number of characters. Your code must have at least 2 lines, with at least 3 chars on each line.
Also, each line of code must be distinct to a certain threshold. Distinctness is calculated using the Levenshtein distance. The threshold is 85%, meaning the Levenshtein distance between any two lines must be greater than or equal to 0.85\*w, where w is the number of characters used in a line of your rectangle.
And for convenience, here is a [Levenshtein distance calculator](https://planetcalc.com/1721/) and a [character length calculator](http://ethproductions.github.io/bytes/?e=chars).
---
# Scoring
This is a [code-bowling](/questions/tagged/code-bowling "show questions tagged 'code-bowling'") variant. The program with the highest number of characters wins!
[Answer]
# Python 3, 89 bytes
```
a='a=%r;b=%r;p=\\';b='print;p(a%(a,b));';p=\
print;p(a%(a,b));c='c=%r;p(b+c%%c)';p(b+c%c)
```
[**Try it online**](https://tio.run/nexus/python3#@59oq55oq1pknQQiCmxjYtSBTPWCosy8EusCjURVjUSdJE1Na3WQHBeGcLKtejJYo0aSdrKqarKmOpSZrPn/PwA)
The Levenshtein distance is 38, which is 86.36% of 44.
**Explanation:**
This is similar to the standard quine `s='s=%r;print s%%s';print s%s`. I had to try a lot of combinations and modifications in order to find my program. Creating the function `p` was used to make the second line shorter. The `\` on the end of the first line is a line-continuation character.
### a
```
a='a=%r;b=%r;p=\\'
```
* A string template that results in the first line
### b
```
b='print;p(a%(a,b));'
```
* String that represents the first part of the 2nd line
### p
```
p=\
print
```
* Shorten stuff, change lengths
### line 1
```
p(a%(a,b))
```
* Print the first line
### c
```
c='c=%r;p(b+c%%c)'
```
* String representing itself plus the part after that prints `b`
### line 2
```
p(b+c%c)
```
* Outputs the second line
] |
[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/102101/edit).
Closed 7 years ago.
[Improve this question](/posts/102101/edit)
In your favorite programming language, create an application that restarts itself once, after n seconds.
You need to find a way to restart after exiting the program. EG: run cmd to do it for you. Make sure it waits an amount of seconds specified by the user before restarting
For clarification: You can run a second program, or compile one at runtime to do the work for you.
Also, make sure the program works every time you execute it, not only once.
Example of algorithm:
```
If hasntrestartedalready
read i
exit
wait(i)
restart
end if
```
Least amount of bytes wins.
[Answer]
# Batch, ~~34~~ 28 bytes
```
timeout/t %1
if %1 neq [] %0
```
Input time in seconds as the first argument. If no argument is present, as well as after restarting, it spews out error messages (follow both commands with `2>NUL` to get rid of them). The new instance opens in the same window (OP said it's allowed).
[Answer]
# bash + at, 29 bytes
```
at now+$[$1/60]min<<<bash\ $0
```
# zsh + at, 28 bytes
```
at now+$[$1/60]min<<<zsh\ $0
```
# bash + at or zsh + at, 23 bytes, arguably cheating
```
at now+$[$1/60]min<<<$0
```
The first version re-executes the program after the number of seconds given as a command-line argument (which must be a multiple of 60 because `at` has only minute granularity). `at` is a standard POSIX program for scheduling programs to be run in the future. The 29-byte and 28-byte programs each rerun the program with the shell it's designed for. The 23-byte program doesn't specify a shell, and thus may well accidentally rerun it with `sh`, which is likely to be unable to parse it; it's up to you whether you consider it reasonable for the restart to happen in the wrong language or not, so I presented both versions.
The time to wait is taken as a command-line argument. This means that the argument won't be present in the rerun, and thus the rerun will exit (with an error message due to the malformed expression, but which will be hidden by `at`; on some systems, it might be sent to you by email, but mine doesn't have that set up) rather than keep rerunning indefinitely.
`bash` considers the `$[]` syntax for arithmetic obsolete, but it still works and is shorter than the "official" syntax. `zsh` is fine with it, as far as I could tell from the documentation.
] |
[Question]
[
**This question already has answers here**:
[Write a brainfuck translator](/questions/19899/write-a-brainfuck-translator)
(9 answers)
Closed 8 years ago.
## The Task
Write the shortest program, that accepts script in brainfuck from `STDIN` (or equivalent) and outputs to `STDOUT` (or equivalent) a program written in the SAME language you're using.
For example, if you write in Java, with the input
```
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
```
The output can be
```
public class B {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
```
[Answer]
# Brainfuck, 5 bytes
```
+[,.]
```
This sentence circumvents the 30 char answer requirement.
] |
[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/48763/edit).
Closed 8 years ago.
[Improve this question](/posts/48763/edit)
You are a robot. You are stranded in a small cage with weird humans wearing weird suits looking at you. Your solar panel is malfunctioning, and your energy is running out. On the wall there is a riddle, and if you answer correctly the humans will grant you access to an energy source (yay!). However your RAM unit is leaking power, and the more you use it, the more energy will be lost.
>
> For each byte you access, you spend 1 energy unit (a bit costs 1/8 energy).
>
>
> The program that uses the least energy wins.
>
>
> Arrays cost the sum of all their variables. Strings and other non-fixed-length variables/arrays are prohibited, as your bot will be unable to calculate how much energy it spent. (Recursion is prohibited too!)
>
>
>
The riddle is weird, it changes after a while, so your bot must not hardcode the answer.
The riddle is a mathematical challenge:
>
> We shall input you with 3 variables, and they are free, but you shall not change them.
>
>
> For these 3 inputs, `a`, `b` and `c`, thou shalt calculate an integer `p` equivalent to `floor(pi * 10^(c-1))`, then you shall calculate `x = a!/b!`. Then you shall add to `x` the integer `p`. If and only if `c` is greater than `x`, you shall yell `Pi!!!!`
>
>
> `a`, `b` and `c` are integers smaller than the number 13.
>
>
>
*Example:* for `a = 5`, `b = 4`, and `c = 3`, calculate `5!/4! + 314`. as `x = 5`, and `c = 3`, don't yell `Pi!!!!`
Once finished calculating, your bot should output the answer. The input can be either in form of calling a function or the user typing a number when prompted.
If 2 bots have the same energy spending, the shortest code wins.
Also, the energy cost is for the worst case (that's why I said `a`, `b` and `c` are smaller than 13). (Extra clarification: the language overheads don't count, unless you abuse them to store data.)
[Answer]
## AVR (274 bytes, 0 energy points)
With all those fancy high-level languages you're never really sure how much RAM you're accessing. The only way to be sure is to ~~nuke it from orbit~~ go down to the bytes. Fortunately I just happen to be teaching myself assembler at the moment.
This submission is a subroutine that uses the [AVR-GCC calling convention](https://gcc.gnu.org/wiki/avr-gcc#Calling_Convention). Fortunately it so happens that both the return value and the arguments fit in registers. The return value will be at most `12! + floor(pi * 10^11) = 0x49 41 e6 f2 4e` (five bytes) and each of the arguments is at most `12` (one byte each). Each size is rounded up to the nearest multiple of two, so we get a total size of `6 + 2 + 2 + 2 = 12` bytes. Starting at `R25`, the return value fits in `R20`-`R24`, and the arguments live in `R18`, `R16`, and `R14`.
Note that as per the rules ("... but you shall not change [the inputs].") I don't write to `R18`, `R16`, or `R14`. I also don't explicitly use the stack or access anything other than the registers, meaning only two bytes are ever read from RAM during the whole program: `RET` reads the return address from the stack. However, the rules state "language overheads don't count," so the total score is zero.
The only other oddity is that I don't have a `printf` function, so in order to "yell" I bit-bang a generic parallel interface on port D. (That's digital pins 0-6 if you run this on an Arduino UNO, with pin 7 being the clock.)
Here is the code itself. All the jumps are relative, so you can plop this anywhere in your program and have it work.
```
4e e4 56 ef 69 e5 75 e2 89 e4 90 e0
22 24 23 94 33 24 44 24 55 24 77 24
60 2e 63 94 20 17 10 f4 22 24 12 c0
26 15 80 f0 56 9c 50 2c 46 9c 40 2c
51 0c 36 9c 30 2c 41 0c 57 1c 26 9c
20 2c 31 0c 47 1c 57 1c 63 94 ee cf
57 14 01 f5 47 14 f1 f4 37 14 e1 f4
2e 14 d0 f4 10 e5 1b b9 10 68 1b b9
19 e6 1b b9 10 68 1b b9 11 e2 1b b9
10 68 1b b9 1f 77 1b b9 10 68 1b b9
1f 77 1b b9 10 68 1b b9 1f 77 1b b9
10 68 1b b9 00 00 7b b8 1c e0 61 2e
6e 18 c9 f1 13 e3 81 9f 80 2d 91 2d
71 9f 70 2d 81 0d 97 1d 61 9f 60 2d
71 0d 87 1d 97 1d 51 9f 50 2d 61 0d
77 1d 87 1d 97 1d 41 9f 40 2d 51 0d
67 1d 77 1d 87 1d 97 1d 45 0f 56 1f
67 1f 78 1f 89 1f 97 1d 46 0f 57 1f
68 1f 79 1f 87 1d 97 1d 48 0f 59 1f
67 1d 77 1d 87 1d 97 1d 45 2f 56 2f
67 2f 78 2f 89 2f 99 27 86 95 77 95
67 95 57 95 47 95 6a 94 39 f6 42 0d
53 1d 64 1d 75 1d 87 1d 08 95
```
Here is the breakdown, including a short header to demonstrate calling the function.
```
0x0000 1fef ldi r17, 0xFF ; write 1111 1111
0x0002 1ab9 out 0x0a, r17 ; to port D direction register
0x0004 10e0 ldi r17, 0x00 ; write 0000 0000
0x0006 1bb9 out 0x0b, r17 ; to port D output register
0x0008 25e0 ldi r18, 0x05 ; set a to 5
0x000a 04e0 ldi r16, 0x04 ; set b to 4
0x000c 13e0 ldi r17, 0x03 ;
0x000e e12e mov r14, r17 ; set c to 3 (can't ldi, r14 < r16)
0x0010 0e940a00 call 0x14 ; call our subroutine @ 0x0014
0x0014 4ee4 ldi r20, 0x4E ; initialize output
0x0016 56ef ldi r21, 0xF6 ; with maximum 'pi integer'
0x0018 69e5 ldi r22, 0x59 ; Floor[Pi*10^11]
0x001a 75e2 ldi r23, 0x25 ; = 314 159 265 358 (12 digits)
0x001c 89e4 ldi r24, 0x49 ; = 0x 49 25 59 f6 4e
0x001e 90e0 ldi r25, 0x00
0x0020 2224 eor r2, r2 ; initialize x
0x0022 2394 inc r2 ; to 1
0x0024 3324 eor r3, r3 ; (eor clears a byte)
0x0026 4424 eor r4, r4
0x0028 5524 eor r5, r5
0x002a 7724 eor r7, r7 ; r7 stays zero (handy)
0x002c 602e mov r6, r16 ; count = b
0x002e 6394 inc r6 ; count++
0x0030 2017 cp r18, r16 ; if a >= b
0x0032 10f4 brcc .+4 ; go to loop @ 0x0038
0x0034 2224 eor r2, r2 ; otherwise x is zero
0x0036 12c0 rjmp .+36 ; go to end of loop @ 0x005c
0x0038 2615 cp r18, r6 ; if a < count
0x003a 80f0 brcs .+32 ; go to end of loop @ 0x005c
0x003c 569c mul r5, r6 ; otherwise multiply high byte by count
0x003e 502c mov r5, r0 ; copy low byte of result (high byte = 0)
0x0040 469c mul r4, r6 ; multiply second byte by count
0x0042 402c mov r4, r0
0x0044 510c add r5, r1 ; carry
0x0046 369c mul r3, r6 ; multiply third byte
0x0048 302c mov r3, r0
0x004a 410c add r4, r1
0x004c 571c adc r5, r7
0x004e 269c mul r2, r6 ; multiply low byte
0x0050 202c mov r2, r0
0x0052 310c add r3, r1
0x0054 471c adc r4, r7
0x0056 571c adc r5, r7
0x0058 6394 inc r6 ; count++
0x005a eecf rjmp .-36 ; return to start of loop @ 0x0038
0x005c 5714 cp r5, r7 ; if any of the high bytes of x
0x005e 01f5 brne .+64 ; are nonzero
0x0060 4714 cp r4, r7 ; then jump past 'yelling'
0x0062 f1f4 brne .+60 ; @ 0x00a0
0x0064 3714 cp r3, r7
0x0066 e1f4 brne .+56
0x0068 2e14 cp r2, r14 ; only the low byte is a comparison
0x006a d0f4 brcc .+52 ; since c is only one byte long
0x006c 10e5 ldi r17, 0x50 ; write 'P' to buffer
0x006e 1bb9 out 0x0b, r17 ; write to PORTD
0x0070 1068 ori r17, 0x80 ; set clock bit (buffer |= 1000 0000)
0x0072 1bb9 out 0x0b, r17 ; PORTD
0x0074 19e6 ldi r17, 0x69 ; 'i'
0x0076 1bb9 out 0x0b, r17 ; PORTD
0x0078 1068 ori r17, 0x80 ; 1000 0000
0x007a 1bb9 out 0x0b, r17 ; PORTD
0x007c 11e2 ldi r17, 0x21 ; '!'
0x007e 1bb9 out 0x0b, r17 ; PORTD
0x0080 1068 ori r17, 0x80 ; 1000 0000
0x0082 1bb9 out 0x0b, r17 ; PORTD
0x0084 1f77 andi r17, 0x7F ; clear clock bit (buffer &= 0111 1111)
0x0086 1bb9 out 0x0b, r17 ; PORTD
0x0088 1068 ori r17, 0x80 ; 1000 0000
0x008a 1bb9 out 0x0b, r17 ; PORTD
0x008c 1f77 andi r17, 0x7F ; 0111 1111
0x008e 1bb9 out 0x0b, r17 ; PORTD
0x0090 1068 ori r17, 0x80 ; 1000 0000
0x0092 1bb9 out 0x0b, r17 ; PORTD
0x0094 1f77 andi r17, 0x7F ; 0111 1111
0x0096 1bb9 out 0x0b, r17 ; PORTD
0x0098 1068 ori r17, 0x80 ; 1000 0000
0x009a 1bb9 out 0x0b, r17 ; PORTD
0x009c 0000 nop ; baud rate is 1/4 processor speed
0x009e 7bb8 out 0x0b, r7 ; PORTD
0x00a0 1ce0 ldi r17, 0x0C ; buffer = 12
0x00a2 612e mov r6, r17 ; count = buffer (# of places in p)
0x00a4 6e18 sub r6, r14 ; count -= c (# of /= 10 we need)
0x00a6 c9f1 breq .+114 ; if count == 0 skip loop @ 0x011a
0x00a8 13e3 ldi r17, 0x33 ; buffer = 51
0x00aa 819f mul r24, r17 ; following the same procedure as before
0x00ac 802d mov r24, r0 ; we multiply p by 51
0x00ae 912d mov r25, r1
0x00b0 719f mul r23, r17 ; since we can't divide by 10
0x00b2 702d mov r23, r0 ; we divide by 5
0x00b4 810d add r24, r1 ; by multiplying by
0x00b6 971d adc r25, r7 ; 0b0.00110011001100110011
0x00b8 619f mul r22, r17 ; equivalent to multiplying by
0x00ba 602d mov r22, r0 ; 0b110011 = 51
0x00bc 710d add r23, r1 ; then repeatedly adding to itself
0x00be 871d adc r24, r7 ; shifted right by one byte
0x00c0 971d adc r25, r7
0x00c2 519f mul r21, r17
0x00c4 502d mov r21, r0
0x00c6 610d add r22, r1
0x00c8 771d adc r23, r7
0x00ca 871d adc r24, r7
0x00cc 971d adc r25, r7
0x00ce 419f mul r20, r17
0x00d0 402d mov r20, r0
0x00d2 510d add r21, r1
0x00d4 671d adc r22, r7
0x00d6 771d adc r23, r7
0x00d8 871d adc r24, r7
0x00da 971d adc r25, r7
0x00dc 450f add r20, r21 ; add p to itself, shifted one byte
0x00de 561f adc r21, r22
0x00e0 671f adc r22, r23
0x00e2 781f adc r23, r24
0x00e4 891f adc r24, r25
0x00e6 971d adc r25, r7
0x00e8 460f add r20, r22 ; shifted two bytes
0x00ea 571f adc r21, r23
0x00ec 681f adc r22, r24
0x00ee 791f adc r23, r25
0x00f0 871d adc r24, r7
0x00f2 971d adc r25, r7
0x00f4 480f add r20, r24 ; shifted four bytes
0x00f6 591f adc r21, r25
0x00f8 671d adc r22, r7
0x00fa 771d adc r23, r7
0x00fc 871d adc r24, r7
0x00fe 971d adc r25, r7
0x0100 452f mov r20, r21 ; shift right one byte
0x0102 562f mov r21, r22
0x0104 672f mov r22, r23
0x0106 782f mov r23, r24
0x0108 892f mov r24, r25
0x010a 9927 eor r25, r25 ; clear top byte
0x010c 8695 lsr r24 ; finally divide by two
0x010e 7795 ror r23 ; by shifting right one bit
0x0110 6795 ror r22
0x0112 5795 ror r21
0x0114 4795 ror r20
0x0116 6a94 dec r6 ; count--
0x0118 39f6 brne .-114 ; if count != 0, repeat @ 0x00a8
0x011a 420d add r20, r2 ; add x to p
0x011c 531d adc r21, r3
0x011e 641d adc r22, r4
0x0120 751d adc r23, r5
0x0122 871d adc r24, r7
0x0124 0895 ret ; return
```
Note that the since the subroutine directly follows the main routine, the subroutine is actually executed twice. The second `RET` call then tries to read from an empty stack. I left this behavior in the minimal example, since it's not a problem if you go step-by-step through the AVR simulator, and I wanted to keep the byte count low.
## Mathematica (70 bytes, 6 energy points)
```
Function[{a,b,c},If[c>a!/b!,Print["Pi!!!!"]];a!/b!+Floor[Pi 10^(c-1)]]
```
* `a`, `b`, and `c` are 'free', and don't count towards the number of accesses.
* The string contains six characters, which count as six bytes.
[Answer]
Both of these are ports of @IsmaelMiguel's answer.
# K, 59 bytes, # of accesses is proportional to input size
```
f:{:[z>(l[x]%(l:*/1+!:)y)+0$z#"3141592653589";"PI!!!!";""]}
```
The number of accesses would be something like (assuming a, b, and c are free):
```
a*4+b*4+19
```
# C89, 172 bytes (DON'T LOOK! CAST AWAY!)
```
int l(int n){int r=1;while(n--)r*=r;return r;}char s[]="PI!!!!";char*f(int a,int b,int c) {char p[]="3141592653589";p[c-1]=0;if(l(a)/l(b)+strtol(p,0,0)>=c)s[0]=0;return s;}
```
Apparently we're not allowed to use recursion, so this increased by several characters. Darn it.
Again assuming a, b, and c are free, the # of accesses might be something like:
```
a*4*4+b*4*4+3*4+3*8+15 == a*16+b*16+51
```
Thanks to @mbomb007 for pointing out I accidentally forgot an exclamation mark in "PI!!!!".
[Answer]
# Javascript (155 bytes, 14+ accesses)
Alright, this isn't the most golfed answer.
Quoting this: "**Arrays cost the sum of all their variables**"... I have no idea how to interpret this, since an array is simply a set of values all aligned in the memory.
Also, there's no information about how to access functions or anything else.
But here is the code:
```
function(a,b,c){var m=[1,1,2,6,24,120,720],f=function(n){return m[n]=m[n]?m[n]:n*f(n-1)};return ((f(a)/f(b))+(+'3141592653589'.substr(0,c)))<c?'PI!!!':'';}
```
For the score (using a=5, b=4, and c=3):
1. Creates an array with the factorial until 7 already there (? accesses)
2. Creates a variable `f` with a function to access the array (? accesses)
3. Calculates the factorial of `a` (2 accesses)
4. Calculates the factorial of `b` (2 accesses)
5. Divides them (2 accesses)
6. Calculates the sum of the number "equivalent to PI" ~~(`Math.PI*Math.pow(10,c)>>0`)~~ now it is only 3 accesses since it fetches `c` characters from the string and converts to integer:
* ~~Gets the value of PI (∞ accesses)~~
* ~~Calculates the power of 10 to multiply by `Math.PI` (∞ accesses + 1)~~
* ~~Sums it all together (2 accesses)~~
* ~~Rounds it (1 access)~~
7. Compares with `c` (2 accesses)
8. Either returns an empty string (0 accesses) or `PI!!!!` (6 accesses).
~~Result: To be improved! The battery would die in no time! **DO NOT RUN THIS CODE ON YOUR ROBOT OR IT WILL EXPLODE**
I assume that the access to the `window` object is ∞ (infinite) due to the fact that it contains everything, including itself.~~
Conclusion: I'm missing some crucial information and explanation to calculate the final number of accesses. But shouldn't be too bad, right?
---
Why am I using `var`? Simple: if it is declared without `var`, it is effectively accessing the `window` object which is a ∞ (infinite) number of accesses and the battery wouldn't even last 1 nanosecond. We would have a very fast drain, probably followed by an explosion.
---
# Javascript (165 bytes, 31 bytes for the factorial array + 16 accesses):
This one should be easier to calculate
```
function(a,b,c){var m=[1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800];return ((m[a]/m[b])+(+'3141592653589'.substr(0,c)))<c?'PI!!!':'';}
```
It has a 31 bytes-long list with all the 13 factorial numbers required.
It was calculated with the following code:
```
var i=0,m=[1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800],k;for(k in m)i+=Math.ceil(m[k].toString(2).length/8);
```
This makes it faster (if time is critical) and cleaner both for humans and machines. With a **VERY** good branch-prediction, the number of accesses could be reduced to 7 accesses.
It works as the code above, except that it doesn't have to calculate the factorial.
---
# Javascript (3 bytes, self-destruction)
Yes, the smallest losing entry!
It drains your battery so fast it will explode!
It's simple, just run:
```
top
```
And you are set. `top` is a variable that will access to `window.top`, which is the same as `window`, which has recursion **EVERYWHERE**
---
# Javascript (31\*2+6+6 bytes (592 bits), 187\*2+42+38=494 bits ):
Same thing as before, but a lot easier to calculate the number of accesses:
```
function(a,b,c){var m=[1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800];return ((m[a]/m[b])+(''.substr.call(3141592653589,0,c)))<c?'PI!!!':'';}
```
Empty strings and `0` aren't being calculated. Why? They are **NOTHING** in the memory. They only have a datatype.
The aray is being accessed twice, so, I'm counting that the entire array must be scattered.
If not, then the number of accesses drops to **22 bytes (146 bits)**!!!
That is for the worst case!!!
[Answer]
### Java (4 Energy points, maybe)
Here's my solution. I am not entirely sure how to score it as I might be invalid.
Calculating `p` wasn't part of the output so I skipped it (the people holding the bot wouldn't know if it was calculated or not). Also, I'm not sure if this is counts for hardcoding and I don't have enough rep to comment to ask.
```
public class Bot {
public void foo(final int a, final int b, final int c) {
if (b > a) {
return;
}
int x = a - b;
if (x > 4) {
return;
} else if (x == 3 && c < 7) {
return;
} else if (x == 2 && c < 3) {
return;
} else if (c < 2) {
return;
}
System.out.println("Pi!!!!");
}
}
```
] |
[Question]
[
You have a library - a fully loaded 2014 [Babylon.js](http://www.babylonjs.com/).
You have a fragment shader - let's call it sample.fragment.fx.
You have a scene - loaded ahead of time, possibly from a .babylon JSON file.
Your goal is to assign the fragment shader to every textured object in the scene using a snippet of JavaScript or TypeScript code.
**Scoring:**
The main multiplier is calculated in the form of one divided by the total number of bytes in the snippet not counting whitespace characters used for formatting.
Additional multipliers (apply one for each condition met) -
\*0.5 (bad) - The solution does not reference the "sample" fragment shader by name.
\*0.8 (bad) - The solution is presented in TypeScript.
\*1.1 (good) - The solution implements a proper for loop (either the for or forEach keyword is used).
\*1.2 (good) - The solution intelligently applies the shader only to objects that meet a certain arbitrary criterion, for example: it has texture, or it has a certain prefix in its name.
\*1.3 (good) - After all multipliers are applied, the score is greater than 0.008.
This should remain open indefinitely. The highest score wins.
[Answer]
## In Javascript
```
// The suffix of all meshes wich should have the shader applied
var suffix = "shader";
//If true, the shader will be applied on this mesh
var predicate = function(mesh) {
return (
mesh.material
&& mesh.name.indexOf(suffix , mesh.name.length - suffix.length) !== -1
);
};
// Creation of the shader material
var shaderMaterial = new BABYLON.ShaderMaterial("sampleShader", scene, "sample", {
attributes: ["position"],
uniforms: ["worldViewProjection"]
});
// Apply the shader on all meshes
scene.meshes.forEach(function(m) {
if (predicate(m)) {
m.material = shaderMaterial;
}
});
```
[Answer]
```
var t = new BABYLON.ShaderMaterial("sh", scene, "./sample", {
attributes: ["uv"], uniforms: ["view"]
});
scene.meshes.forEach(function(m) { m.material = m.material && t; });
```
score : 1/164 \* 1.1 (forEach) \* 1.2 (material predicate) = 0.00804 \* 1.3 = **0.0104**
] |
[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/33087/edit).
Closed 9 years ago.
[Improve this question](/posts/33087/edit)
The challenge is to write a fake infinite loop in any imperative programming language.
At first sight, the code should seem not to halt at all.
As a naive example:
```
int f(int x)
{
return f(4.0);
}
int f(double x)
{
return 0;
}
```
**But remember**
You're not allowed to use overflows:
```
int f(int x)
{
if(x < 0) return -1;
return f(x*x);
}
```
is illegal. When the number exceeds the integer limit, the function will stop. It's a good trick. But not good enough :)
The answer with the highest votes wins! Duration is 1 week.
[Answer]
# Bash
```
trap 'exec "$0"' exit
```
It re-execs itself when it should exit. So it will never really exit.
>
> It doesn't have the shebang. So you must run it like `bash a.sh`. And `$0` will probably not be something executable.
>
>
>
] |
[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/28727/edit)
Write a program that is a sonnet, and when run prints out a sonnet.
By "sonnet" I mean:
* 14 lines
* Each line, when read aloud, has 10 syllables
Symbols can be ignored, or pronounced in whatever reasonable way you want.
Popularity contest, most upvotes wins.
[Answer]
## Linux shell script
Cheating, I know.
### Edit: a version that rhymes:
(Thanks @professorfish for the idea of using the options of `cat`)
```
#!/bin/cat -bAse
In thee thy summer, ere thou be distilled:
Make sweet some vial; treasure thou some place
With beauty's treasure ere it be self-killed.
That use is not forbidden usury,
Which happies those that pay the willing loan;
That's for thy self to breed another thee,
Or ten times happier, be it ten for one;
Ten times thy self were happier than thou art,
If ten of thine ten times refigured thee:
Then what could death do if thou shouldst depart,
Leaving thee living in posterity?
Be not self-willed, for thou art much too fair
To be death's conquest and make worms thine heir.
```
First line pronounced as "shebang slash bin slash cat negative base". The line numbers and `$` in the output are to be ignored when reading aloud.
Taken from [Shakespeare's Sonnet VI](http://www.shakespeares-sonnets.com/sonnet/6).
### Old version:
```
#!/usr/bin/env cat
For slander's mark was ever yet the fair;
The ornament of beauty is suspect,
A crow that flies in heaven's sweetest air.
So thou be good, slander doth but approve
Thy worth the greater, being wooed of time;
For canker vice the sweetest buds doth love,
And thou present'st a pure unstained prime.
Thou hast passed by the ambush of young days
Either not assailed, or victor being charged;
Yet this thy praise cannot be so thy praise,
To tie up envy, evermore enlarged,
If some suspect of ill masked not thy show,
Then thou alone kingdoms of hearts shouldst owe.
```
First line pronounced as "she-bang slash use-r slash bin slash env cat".
Taken from [Shakespeare's Sonnet LXX](http://www.shakespeares-sonnets.com/sonnet/70).
] |
[Question]
[
### Introduction
The Babylonians had a clever method for finding square roots. To find the square root of a number `N`, you start with a `guess`, then refine it by repeatedly evaluating a line of computer code (or papyrus scroll equivalent):
```
guess = (guess + N/guess) / 2
```
If the guess is smaller than sqrt(N), N/guess must be larger than sqrt(N), so averaging these two terms should get you closer to the true answer. It turns out this method converges fairly quickly to the correct answer:
```
N = 7
guess = 1
guess = 4.0
guess = 2.875
guess = 2.65489
guess = 2.64577
guess = 2.64575
guess = 2.64575
```
### Extension
Does an equivalent algorithm exist for matrices? Throwing all mathematical rigor aside, if we wish to find the 'square root' of a square matrix `M`, we may again start with a `guess`, then refine it by repeatedly evaluating a line of code:
```
guess = (guess + inverse(guess)*M) / 2
```
where inverse() is the matrix inverse function, and \* is matrix multiplication. Instead of 1, our initial guess is an identity matrix of the appropriate size.
However, convergence is no longer guaranteed - the algorithm diverges for most (but not all) inputs. If M produces a convergent series, it is a **Babylonian matrix**. Furthermore, the converged value is actually the real square root of the matrix (i.e., `guess*guess = M`).
### Example
Here's an example using a 2x2 matrix, showing convergence of the series:
```
M = [[7,2],[3,4]]
guess = [[1., 0. ], [0., 1. ]] <-- 2x2 identity matrix
guess = [[4., 1. ], [1.5, 2.5 ]]
guess = [[2.85294, 0.558824], [0.838235, 2.01471]]
guess = [[2.60335, 0.449328], [0.673992, 1.92936]]
guess = [[2.58956, 0.443035], [0.664553, 1.92501]]
guess = [[2.58952, 0.443016], [0.664523, 1.92499]]
guess = [[2.58952, 0.443016], [0.664523, 1.92499]]
```
After only a few iterations, the series converges to within 1e-9. After a while, it grows unstable as rounding errors add up, but the initial stability is demonstrated, which is sufficient.
### Task
Your job is to find a square matrix `M`, populated by the integers 1 through 9, which, when given an initial guess of an identity matrix of the proper size, converges successfully. Matrices should be submitted as comma-delimited text (or attached text files, if they are too large), with either brackets or newlines separating subsequent rows.
### Rules
Even though the matrix M and starting guess use integers (mainly for display convenience), all arithmetic should be conducted using double-precision floating point. Integer-specific operators (such as 3/2 evaluating to 1) are prohibited.
Divide-by-zero errors, singular matrices, and over/underflows cannot be used to coerce a sequence into 'converging'. The values must be proper floating-point numbers at all times to be considered to have converged.
The algorithm is considered to have converged if an iteration produces no change larger than 1e-9, in any individual cell.
You may use external mathematics libraries for matrix inversion (no need to reinvent the wheel).
### Win Condition
The winner is the largest submitted valid Babylonian matrix made of integers 1-9, after one week. You must also submit the code you used to find the matrix.
[Answer]
We produce such a matrix of any dimension `n`. It is simply a matrix of all 1's except 2's on the diagonal.
```
r = range(n)
M = [[1 + (i==j) for i in r] for j in r]
```
Example:
```
n=5
M=[[2 1 1 1 1]
[1 2 1 1 1]
[1 1 2 1 1]
[1 1 1 2 1]
[1 1 1 1 2]]
#Within 10 steps, the procedure converges to the matrix's square root
[[ 1.28989795 0.28989795 0.28989795 0.28989795 0.28989795]
[ 0.28989795 1.28989795 0.28989795 0.28989795 0.28989795]
[ 0.28989795 0.28989795 1.28989795 0.28989795 0.28989795]
[ 0.28989795 0.28989795 0.28989795 1.28989795 0.28989795]
[ 0.28989795 0.28989795 0.28989795 0.28989795 1.28989795]]
```
In general, the procedure converges for matrices with positive real eigenvalues. This is because if we work in the basis of eigenvectors of the original matrix, it and all its iterates are diagonal matrices, and we can view the procedure as applying the Babylonian method to each individual diagonal entry. The starting matrix is the still the identity in this basis.
Since the Babylonian method converges only if the original value was positive, the matrix version converges when every eigenvalue is real and positive. I'm not sure what happens for complex eigenvalues.
I constructed the given matrix to have positive eigenvalues as follows. First, start with the matrix of all ones, which is rank-1, and so has a single eigenvalue (of n) and all others 0. Then, add the identity, which shifts the eigenvalues up by 1 to get (n+1,1,1,...,1). Iterating makes the eigenvalues converge to (sqrt(n+1),1,1,...,1). Note that the 1's are unchanged by each iteration.
[Answer]
Here's a 10x10 Babylonian matrix as a first target:
```
[[9, 8, 6, 5, 1, 1, 6, 7, 1, 6],
[8, 7, 4, 9, 9, 5, 4, 8, 5, 9],
[7, 1, 8, 8, 6, 8, 6, 6, 4, 1],
[7, 8, 9, 9, 5, 1, 1, 6, 9, 9],
[6, 9, 3, 4, 1, 9, 1, 7, 4, 9],
[9, 1, 1, 1, 5, 4, 5, 6, 7, 1],
[8, 6, 8, 2, 4, 4, 6, 8, 2, 2],
[5, 4, 9, 3, 3, 5, 5, 6, 4, 1],
[2, 4, 4, 8, 6, 8, 3, 3, 7, 6],
[3, 9, 9, 7, 7, 9, 6, 5, 1, 8]]
```
which converges to
```
[[3.20594, 1.60102, 0.237288, -0.0745693, -1.07811, -0.255869, -0.0182269, 1.70256, 0.355871, 1.11176],
[0.62321, 1.19922, -0.514309, 2.2604, 1.96759, 1.41485, -0.066537, 1.37868, -0.613093, 1.35704],
[0.919805, 0.453479, 2.54444, 0.717525, -0.00569383, 1.54527, 0.131113, 0.916813, 0.443482, -0.0251371],
[0.163383, -0.597711, 0.751538, 3.69952, 2.37728, -0.578767, 1.24375, -0.0922065, 0.749781, 0.623908],
[2.27446, 2.7975, 0.171454, -1.6263, -1.12639, 1.22686, -2.69745, 2.36239, 1.6901, 2.1349],
[0.669566, -1.57916, -0.722141, 1.35884, 2.43496, 2.25887, 2.01205, 0.241215, 0.342665, -0.714146],
[0.50365, 0.472729, 1.37547, 0.32966, 1.36842, 0.0550458, 2.90591, 0.520055, -0.257277, -0.347814],
[0.205106, 0.286162, 1.89821, 0.141372, 0.521793, 0.0638244, 1.65691, 1.04034, 0.81816, -0.30955],
[0.0679229, 1.01126, 0.553701, 0.627696, -0.0400446, 1.21608, -0.397756, 0.35419, 2.38639, 1.08573],
[-0.200249, 2.31035, 1.89905, -0.124084, 0.0398479, 0.454703, 1.08552, -0.152166, 0.408594, 2.31063]]
```
and was found with this Mathematica code:
```
n = 10;
M = RandomInteger[{1, 9}, {n, n}];
guess = IdentityMatrix[n] // N;
result = NestList[(# + Inverse[#].M)/2 &, guess, 32];
ListPlot[Transpose[Flatten /@ result], Joined -> True]
M // MatrixForm
```
] |
[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/17712/edit).
Closed 10 years ago.
[Improve this question](/posts/17712/edit)
Say i have a list (unorder):
```
Score = ['score1','score10','score6','score2','score22','score12']
Names = ['name1','name10','name6','name2','name22','name12']
email = ['email1','email10','email6','email2','email22','email12']
```
and then Score is sorted to be
```
ScoreSorted = ['score1','score2','score6','score10','score12','score22'].
```
The shortest code (in byte) to sort Name and Email with Score list wins
result of email and names list should be
```
EmailSorted = ['email1','email2','email6','email10','email12','email22'].
NamesSorted = ['name1','name2','name6','name10','name12','name22'].
```
[Answer]
## Ruby 81 bytes
```
m=Score.each_index.sort_by{|i|Score[i]}
p m.map{|i|Names[i]}
p m.map{|i|Email[i]}
```
A golfed implemention of the algorithm below, assuming `Score`, `Names`, and `Email` are all already defined, and that only output of the post-sorted `Names` and `Email` is required.
Sample usage:
```
Score = ['score1','score10','score6','score2','score22','score12']
Names = ['name1','name10','name6','name2','name22','name12']
Email = ['email1','email10','email6','email2','email22','email12']
m=Score.each_index.sort_by{|i|Score[i]}
p m.map{|i|Names[i]}
p m.map{|i|Email[i]}
```
Sample output:
```
["name1", "name10", "name12", "name2", "name22", "name6"]
["email1", "email10", "email12", "email2", "email22", "email6"]
```
---
## Ruby (with natural sort) 123 bytes
```
m=Score.each_index.sort_by{|i|Score[i].scan(/\d+|\D+/).map{|i|i=~/\d/?i.to_i: i}}
p m.map{|i|Names[i]}
p m.map{|i|Email[i]}
```
Correctly sorts strings with any number of digital groupings, as one would sort them 'naturally'. The only caveat is that all strings in the `Score` array must start with a digit, or all must start with a non-digit.
Sample output:
```
["name1", "name2", "name6", "name10", "name12", "name22"]
["email1", "email2", "email6", "email10", "email12", "email22"]
```
---
## Python
Not a code-golf answer.
1. Find the inverse permutation of the list which is to be sorted in lexicographical order (in the problem description, this `Scores` array). This can be achieved in *O(n log n)* time (as the problem is analog to sorting), although the implementation below is *O(n²)*.
2. Apply this permutation to each list. The permute function is *O(n)* complexity.
Sample implementation:
```
def get_inv_perm(items):
size = len(items)
perm = [0]*size
for i in range(size):
for j in range(size): perm[j] += items[j] > items[i]
return perm
def permute(arr, perm):
size = len(arr)
out = [0] * size
for i in range(size):
val = perm[i]
out[i] = arr[val]
return out
if __name__ == "__main__":
Score = ['score1','score10','score6','score2','score22','score12']
Names = ['name1','name10','name6','name2','name22','name12']
Email = ['email1','email10','email6','email2','email22','email12']
perm = get_inv_perm(Score)
print permute(Score, perm)
print permute(Names, perm)
print permute(Email, perm)
```
Sample output:
```
['score1', 'score10', 'score12', 'score2', 'score22', 'score6']
['name1', 'name10', 'name12', 'name2', 'name22', 'name6']
['email1', 'email10', 'email12', 'email2', 'email22', 'email6']
```
Because the sort is lexicographical, `score10` and `score12` appear directly after `score1`. The `get_inv_perm` function assumes the items list is unique. The remaining lists need not be.
[Answer]
Python, 172 bytes. Assumes names and emails are unique. Not particularly efficient as you have to do a lookup for each comparison.
```
NamesSorted=sorted(Names,lambda l,r:cmp(Score[Names.index(l)],Score[Names.index(r)]))
EmailSorted=sorted(email,lambda l,r:cmp(Score[email.index(l)],Score[email.index(r)]))
```
[Answer]
## C++ 117 bytes
```
#define S(a)a##Sorted.push_back(a[i])
for(auto a:ScoreSorted){int i=0;for(auto b:Score)a==b?S(Names),S(Email),0:++i;}
```
Notice that I am making two assumptions:
* strings vectors for to represent all lists
* it is OK to capitalize the name of the unsorted email list (email -> Email)
Sample usage:
```
#include <string>
#include <vector>
#include <iostream>
using namespace std;
int main()
{
vector<string> Score = {"score1","score10","score6","score2","score22","score12"};
vector<string> Names = {"name1","name10","name6","name2","name22","name12"};
vector<string> Email = {"email1","email10","email6","email2","email22","email12"};
vector<string> ScoreSorted = {"score1","score2","score6","score10","score12","score22"};
vector<string> NamesSorted;
vector<string> EmailSorted;
#define S(a)a##Sorted.push_back(a[i])
for(auto a:ScoreSorted){int i=0;for(auto b:Score)a==b?S(Names),S(Email),0:++i;}
for (auto i : NamesSorted) {
cout << i << endl;
}
for (auto i : EmailSorted) {
cout << i << endl;
}
}
```
[Answer]
**Ruby** 108 bytes
```
[names, email, score].map do |z|
z.sort! {|x, y| x.scan(/\d/).join.to_i <=> y.scan(/\d/).join.to_i }
end
puts "#{names}\n#{email}\n#{score}"
```
] |
[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/2821/edit).
Closed 5 months ago.
[Improve this question](/posts/2821/edit)
The challenge is to implement a box blur in any language. The input will be as a 32-bit uncompressed bitmap, BGRA, preceded by one byte defining the radius of the blur and one byte defining the width of the image. The output should be in the same format as the input (minus the blur radius, of course).
Fastest code wins, and a 50-point bounty to the shortest entry, and another to the "most obfuscated" in my opinion.
[Answer]
eTeX, too many chars
```
\immediate\openout5\jobname.out\let\x\newlinechar\x0\catcode0=12\let\y
\linepenalty\def\ndef#1{\expandafter\edef\csname\the#1\endcsname}\loop
\lccode0\x\lowercase{\ndef\x{^^@}}\ifnum\x<255\advance\x1\repeat\def\R
#1 #2 #3 {\Sr#1 \def\Y{#2}\x=0 \Rl#3????}\def\Rle#1\fi#2\Rc{\fi\Rl#1}
\def\Ry#1#2{\ndef{\y;\the\x.#1}{\number`#2 }}\def\Rc#1#2#3#4{\ifnum\Y=
\y\Rle#1#2#3#4\fi\advance\y1 \Ry1#1\Ry2#2\Ry3#3\Ry4#4\Rc}\def\Re{\fi\x
-1\immediate\write5{\Bl1;1.!}\end}\def\Rl#1{\edef\X{\the\x}\advance\x1
\y0 \ifx?#1\Re\fi\Rc#1}\def\Bl#1;{\ifnum\X<#1 \Ble\fi\Bc#1;}\def\Ble
#1!{\fi}\def\Bc#1;#2.{\ifnum\Y<#2 \Bce\fi\By#1;#2.1\By#1;#2.2\By
#1;#2.3\By#1;#2.4\expandafter\Bc\number#1\expandafter;\the\numexpr
#2+1.}\def\Bce#1#2#3;{#1\expandafter\Bl\the\numexpr#3+1;1.}\def\Sr#1
{\x-#1\def~{}\Sl#1 \edef~{\def\noexpand\By####1;####2.####3{\noexpand
\csname\noexpand\the\numexpr(\unexpanded\expandafter{~}+0)/(\unexpanded
{\Bt\X}#1 ####1 *\unexpanded{\Bt\Y}#1 ####2 )\endcsname}}~}\def\Sl#1
{\ifnum#1<\x\else\y-#1 \Sc#1 \advance\x1 \Sl#1 \fi}\def\Sc#1 {\ifnum
#1<\y\else\edef~{\unexpanded\expandafter{~}\unexpanded{\expandafter\t
\csname\the}\numexpr####2+\the\x;\noexpand\the\numexpr####1+\the\y
.####3\endcsname}\advance\y1 \Sc#1 \fi}\def\t#1{\ifx\relax#1\else+#1\fi
}\def\Bt#1#2 #3 {\expandafter\use\the\numexpr(\ifnum#2<#3 1+#2\else
#3\fi+\ifnum\numexpr#2+#3>#1 #1-#3\else#2\fi);}\def\use#1;{#1}
\expandafter\R\noexpand
```
Run as for instance
```
etex filename 10 3 55555555qqqq55555555qqqq5555qqqqqqqq5555qqqqqqqq
```
] |
[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/264316/edit).
Closed 6 months ago.
[Improve this question](/posts/264316/edit)
I have the following Haskell code to generate the the values of the Fibonacci sequence which are even as an infinite list:
```
z=zipWith(+)
g=z((*2)<$>0:0:g)$z(0:g)$(*2)<$>scanl(+)1g
```
This works by starting with 0,2 and then defining every following term to be the sum of:
* twice all prior terms
* the previous term
* twice the term before that
* 2
I'd like to make it shorter, however I want to preserve a few properties of it.
0. It must produce the same list.
1. The solution mustn't calculate intermediate terms of the Fibonacci sequence. The above code calculates each term purely in terms of previous terms of the sequence, and improved versions should as well.
2. The solution can't use any helper functions, other than point-free aliases like `z`.
I really feel like this can be done with only 1 zip, however I can't get anything to work.
How can I shorten this.
[Answer]
# [Haskell](https://www.haskell.org/), 27 bytes
```
g=2:zipWith((+).(*4))g(0:g)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P93WyKoqsyA8syRDQ0NbU09Dy0RTM13DwCpd839uYmaegq1CQVFmXomCikJJYnaqgqGBQvp/AA "Haskell – Try It Online")
Uses the recursive relationship \$g\_n = 4 g\_{n-1} + g\_{n-2}\$.
] |
[Question]
[
# Challenge
You find yourself in a `bash` terminal, and want to do some simple tests
on `sqlite3`.
So you issue the following command:
```
echo "CREATE TABLE T (id INT NON NULL PRIMARY KEY)" | sqlite3 test.db
```
Now you want to insert the first `N` integers (starting from 0, excluding N) into the table `T`.
For convenience, you execute the following
```
N=5 # value arbitrary and large, not known for purposes of the challenge
```
Now for the example case of `N == 5`, you would have to execute the following SQL command:
```
echo "INSERT INTO T VALUES (0), (1), (2), (3), (4);" | sqlite3 test.db
```
But of course, `N` is large, so you want to come op with a `bash` oneliner
to dynamically generate and execute the SQL statement to insert these values.
---
# Rules
* The result of entering the command string into the presented `bash` teminal session (and pressing enter) should be the modification of `test.db` as described in the challenge.
* You must not leave behind any unintended artifacts on disk (ignoring command histories etc.)
* Any cli tool can be called and considered installed, e.g. `python -c`, `ghci -e`, `awk`, ...
* The final command string must be a **single** line of characters enterable in the `bash` terminal session described above
(if we want to get technical, the command string cannot contain a byte with value 10 (LF))
* Your command string must be valid UTF-8
* You don't absolutely have to end in `| sqlite3 test.db`, if the tools you are using
have some built in way to write to `test.db`, that can be used aswell.
(Although it might not help you that much, see the scoring).
* If you are using tools where it is not obvious how to install them for others (let's just say, if the are not available as a [Debian Package](https://www.debian.org/distrib/packages#search_packages)), please add a link on where to get them.
---
# Scoring
Score shall be based on the following metric,
which tries to favor elegant and readable solutions:
* +100 Points by default so we don't have to look at that many negative scores.
* -5 points for every character not in the printable ASCII range (values 32-127, )
* -3 points for every 10 characters above 80 (e.g. 89: -0, 90: -3, 99: -3, 100: -6)
* -2 points for every use of `\`
* -1 point for every use of any of these characters: `(){}[]'"`` (trying to punish nesting here, sorry LISP fans)
The tie breaker are the upvotes, which I hope will respect the spirit of elegant / readable
solutions.
Highest Score wins !
---
Non competing example solution in Haskell to demonstrate Scoring:
```
ghci -e 'import Data.List' -e 'putStr $ "insert into T values" ++ (concat $ intersperse "," $ map (\i -> "(" ++ show i ++ ")") [0..'$N']) ++ ";"' | sqlite3 test.db
```
```
Default: = 100
Non Ascii: 0 * -5 = -0
Length: 164: 8 * -3 = -24
Backslashes: 1 * -2 = -2
Special Chars: 24 * -1 = -24
--------------------------------
Total Points: 50
```
[Answer]
# Score 100 (optimal)
```
echo seq $1Uxargs MRE sqlite3 testNdb Binsert into t values HEMQIB | tr A-Z !-1Iz-~| bash
```
[Attempt This Online!](https://ato.pxeger.com/run?1=Zc4xCsJAEIXhqzyDhRYRgghWgkJACwUFCxWLTTLRxU2iuxNRES9iE1APldu4YgrBYoapvvnvz0CYbVH2zEFJpjaYDLeiAE6oSTCBRaDsRkNGkCkjzezkSmGvZSL0GTs6N51XzrHbLRcUbjMYOqDuzU9CbwzGMx-_9sTaA5ka0vzxMksfhcrJYOiPp6MBrmCNvrtEzfVGF_d2xaeweuD8ZRpSFFoqQqyzBFylPFaddfE93w)
This is the version below, but encoded so that it contains no literal `()"` characters (and with some whitespace removed, so the final thing fits in under 90 characters)
# Score 96
```
seq $1 | xargs -I % sqlite3 test.db "insert into t values (% - 1)"
```
[Attempt This Online!](https://ato.pxeger.com/run?1=ZYw9CsJAFISvMgQDsYgQRLCysPMMYrGbfdHFzd--FzHgTWwC6qFyG1cUmxQzTDHfd39qxadh3HDrrNASQiwLoxHlnpQQRGkXGok1sJWgqkM659B4Wyrf40z9PHp1UqTrccvUYpbhhqvyR0a6Q4yJ2VZMXj62OogvynXESGKkyP6maEIxOcoDZVD4uoT8no_96jB85xs)
Gratuitous whitespace, in the spirit of elegance, since it's still well under 90 bytes.
] |
[Question]
[
## Task
Make code given on the command line that takes an unpacked hex value as input and `eval`s that in Perl. Like this:
```
perl -e 'map{eval}pack q/h*/,q/072796e6470222458656275672370202d6f62756020222b302072796e6470222478616e60202f6e6560202771697020247f6020246f602029647e2c5e622/'
```
But with one additional restriction: Your code must survive any level of `ssh`
(and the example above does not survive because the space would need to be quoted:
```
# This does not work
ssh server perl -e 'map{eval}pack q/h*/,q/072796e6470222458656275672370202d6f62756020222b302072796e6470222478616e60202f6e6560202771697020247f6020246f602029647e2c5e622/'
# This would survive 1 level of ssh but not 2
ssh server perl -e 'map{eval}pack\ q/h*/,q/072796e6470222458656275672370202d6f62756020222b302072796e6470222478616e60202f6e6560202771697020247f6020246f602029647e2c5e622/'
```
)
So:
```
ssh server your_code hexvalue
ssh server ssh server2 your_code hexvalue
ssh server ssh server2 ssh server3 your_code hexvalue
```
should all give the same result. You will not be told the number of levels of `ssh`.
You can assume the login shell is bash.
You can choose to include the hex value in the program (in which case it obviously does not count towards the length of your code) or have it given as an argument to your program.
You are also allowed to preprocess the hex value (e.g. convert it to another format) and use that value instead. But you cannot do the `eval` locally: It must be run on the remote server. The preprocessing code is of course also code thus also part of the byte count.
## Test
Given the value:
```
072796e6470222458656275672370202d6f62756020222b302072796e6470222478616e60202f6e6560202771697020247f6020246f602029647e2c5e622
```
your program should print:
```
There's more than one way to do it.
```
And:
```
4216d3223616d656c622b302072796e6470222140242160296e6024786560246563737562747e2c5e622
```
should print:
```
A camel in the dessert.
```
Finally:
```
072796e647020686f63747e616d65606
```
should print the hostname of the server that you `ssh` to.
## Scoring
Code that only uses Perl wins over code that uses Bash+Perl which wins over code in any other languages.
In case of a tie: Code without warnings wins.
In case of a tie: Shortest code wins.
*Edit*
Clarified preprocessing is allowed, but not for free, and warnings are frowned upon, but not illegal.
[Answer]
# Perl only; (+0 bytes) 23 bytes
Saved two bytes thanks to [Ole Tange](https://codegolf.stackexchange.com/users/25339/ole-tange) themself! (`'+'` -> `+`)
```
map{eval}pack+q/h*/,q/$hexvalue/
```
Disclaimer: I have no experience with Perl whatsoever.
However, this seems to work fine, I simply replaced the single space in the example with `'+'`, which has now been golfed to just `+`.
For example:
```
ssh localhost ssh localhost [...] ssh localhost perl -e 'map{eval}pack'+'q/h*/,q/072796e647020686f63747e616d65606/'
```
(We can't seem to ssh even to `localhost` over on [TIO](https://tio.run/##S0oszvj/vyC1KEdBN1VBPTexoDq1LDGntiAxOVu7UD9DS1@nUN/A3Mjc0izVzMTcwMjAzMIszczY3MQ81czQLMXM1MzATF@dq7g4QyEnPzkxJyO/uEQBxKOFmQgexab//w8A "Bash – Try It Online") though)
[Answer]
# Pure [Perl 5](https://www.perl.org/), 6 bytes + 8 bytes for a change to the preprocessing format = 14 bytes
```
eval+v
```
[Try it online!](https://tio.run/##K0gtyjH9/z@1LDFHu8zQ0EjP0NBEz9DAFEgbALGZnrGRnqmBngmI/P8fAA "Perl 5 – Try It Online")
This is followed by the code that you want to evaluate written with codepoints in decimal and separated by periods, e.g.
```
perl -e eval+v112.114.105.110.116.32.50.42.50
```
Produces a warning about ambiguous syntax (the `+` could be interpreted as either unary + (a no-op) or as addition), but the parse that Perl chooses by default works.
## Encoders
The format listed in the question is *not* the usual hex encoding; the first example starts with `07`, which in a normal hexdump, would represent the BEL character. I suspect it has been produced using code that's something like this:
```
print unpack("h*", "print 2*2")
```
(A "regular" hexdump would use the `H*` unpack format, rather than `h*`.)
To produce the format used by this answer, you unpack with `c*` rather than `h*`, and with `$,` set to `"."`:
```
$,=".";print unpack("C*", "print 2*2")
```
Encoding it using Perl therefore takes 8 more bytes than encoding the format stated in the question.
Alternatively, you can use [this online encoder](https://tio.run/##y0rNyan8/98/61HDXL1HDXNSyxJztMuAHOv///8XFGXmlSgYaRkBAA "Jelly – Try It Online"), written in Jelly.
## Explanation
```
eval+vn.n.n.n.n.n…
eval Evaluates a string literal as code
+ No-op (used here as a whitespace substitute)
vn.n.n.n.n.n… String literal specified using character codes
```
All the characters in this program are invariant under shell escaping (it's just letters, digits, `+` and `.`), so it can be passed through any number of shell command lines and will remain intact.
] |
[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/216005/edit).
Closed 3 years ago.
[Improve this question](/posts/216005/edit)
**Prompt:**
You are given two sets of XY coordinates along with two angles (all are floats): `X1 Y1 A1 X2 Y2 A2`. The angles are relative to world coordinates: 0 being straight up or north and going clockwise.
Your program or function has to return a set of two floats of the XY coordinates the two angles cross at.
**Example:**
[](https://i.stack.imgur.com/KOIKr.png)
In this case, the resulting point is between the two inputted points. For the case `100 500 50 300 600 80` (using degrees), the correct answer is `198 582`. Online representation [here](https://www.geogebra.org/calculator/jxqegd4x)
Other examples of edge cases:
`1 1 45 4 4 45` returns `NULL`
`1 4 45 2 4 45` returns `NULL`
<https://i.stack.imgur.com/vlmQO.jpg>
**Rules:**
* Angles can be in radians or in degrees
* The program should have a separate answer if there is not a valid answer: if the two lines are parallel (zero solutions) or the same line (infinitely many solutions)
* The value returned can be represented in any form: `198;582`, `198 582` and `198_582` are all valid
* The answer can be rounded to a full number
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")
[Answer]
# JavaScript (ES6), 76 bytes
Expects the angles in radians. Returns either `[x,y]` or `0` if the lines are parallel or coincident.
```
(x,y,a,X,Y,A)=>a-A&&[(m=(t=Math.tan)(a))*(X-=(x-=m*y)+t(A)*Y,X/=m-t(A))+x,X]
```
[Try it online!](https://tio.run/##bYxLC4JAFIX3/YpZyb3jHR9l4WYCly2CliPRYjDtgY/IIfTXm5aL0OBwuJzvnnPXL10nz9vDiLI6p10mO2ioJU2KYopQbrWILOsIhQQj99pcHaNLBI3IQQkJjZAFb9E2ECGPSbmyEMONdkPq1CVVWVd56uTVBTLwPY/Y@mvMZX7oMc4@o4cdsdUANoOFM4q4mEwR6zXS/jugUT/Rv1IwKS3npe4N "JavaScript (Node.js) – Try It Online")
Or [**71 bytes**](https://tio.run/##bYw7D4JAEIR7f8WVu7DHQ9HQnAmlhYnlEWNxQfAR4IxcDPz6E5TCgMlksplvZ@7qpZrseXsYXutzbgthoaWOFElKKUGxPUIlwIi9MlfPqBpBIToguYCWi8rp0DWQoJOS9EXFhxvdluTJZrpudJl7pb5AAWEQEFt/jfksjAPmsM/oYUdsNYDNYPGMIi4mU8R6jbT/jmjUT/SvFE1Ky3nJvgE) if we can just return `[Infinity,Infinity]` for invalid inputs.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~131~~ \$\cdots\$ ~~106~~ 104 bytes
Saved 9 bytes thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!!
Saved ~~4~~ a whopping 15 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!
```
#define f(x,y,a,X,Y,A)float M=tan(A),m=tan(a),n;printf(a-A?"%f,%f":"0",(n-Y)*M+X,n=(M*Y-m*y-X+x)/(M-m));
```
[Try it online!](https://tio.run/##ddJBT8IwFAfwO5@iqSFpx2vYhhhgTkOMBw8kHCFiTFNaXGTFsCW2Gr66cxSG0@Gh6dpf8@/bSwVbCVEUF0upEi2RIgYscJjBHMZUrTc8R5M455qMKaTug1PQ0ds20bkinI1vcVtBW@ER9jEQzebUm3RmoGMy8eYs9SybdQztkglLKY1OF00fEBebjLCAtlKeaEI/W@hwXy6zPHs2weNT/Bn4PpRjF/1G67BfYr@J/Ije9KEbDHwop8u/Z0y4P9MrA3pn0h1elXh1Jt3h4J90ad6kyOXy2bjqhwPwz6B1BQ7CA4oXvvXEixSvcrsHvDD34cIM78rRx1Bf9rBL22xJ2X6U6KU0sR@5@TpLPuRG1SroHna8n52o03Fn970@1mSC@NRvZ0/RyWxltmm8Mt40E8anLjcyK7NN45XxppU/WuttQ21ca@6PHp8pJu6N0m5boRmqLdgNIhhMADYAHoAJwYbAQ@qSyfn9KpOie3dlolejKnOhMUgD0u5P7lq74kuoNV9lBVunBXv/Bg "C (gcc) – Try It Online")
Either prints the intersection as `%f,%f` or `0` if the lines are parallel or coincident.
] |
[Question]
[
**This question already has answers here**:
[Write the shortest self-identifying program (a quine variant)](/questions/11370/write-the-shortest-self-identifying-program-a-quine-variant)
(48 answers)
Closed 3 years ago.
Write a program that takes a string as an input. For the input:
* If the input **doesn't** match the source code, the program shall output the input intact. (Hence a cat)
* Otherwise, the program shall fall in an infinite loop. (So actually not a cat)
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-0p`, ~~38~~ ~~37~~ 32 bytes
*Saved 5 bytes thanks to a comment by @Sisyphus on another answer.*
```
eval s="1until$_!='eval s=%p'%s"
```
[Try it online!](https://tio.run/##KypNqvz/P7UsMUeh2FbJsDSvJDNHJV7RVh0qpFqgrlqs9P9/cGZuQU6qwqOGORmVqXmJjxrmKhQU5acXJeb@yy8oyczPK/6va1AAAA "Ruby – Try It Online")
The `-0` flag sets the null byte as the input record separator. Without `-0`, a loop would also be entered if the input consisted of the code repeated on more than one line.
] |
[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/205155/edit).
Closed 3 years ago.
[Improve this question](/posts/205155/edit)
# Golf Me a Text Editor
(similar challenges: [Create a simple line editor](https://codegolf.stackexchange.com/questions/117426/create-a-simple-line-editor) and [Line editor (more text here)](https://codegolf.stackexchange.com/questions/128540/line-editor-more-text-here))
I seem to have forgotten which program to use to open, read, and write text files. Something like Noteleaf or VSBro or ... You see my conundrum. But never fear! I know some people who can write one. But I'm a bit limited on space, so shorter programs would be *much* appreciated.
## The Challenge
Create a program, in your language of choice, that can open, read, and write plaintext files. The program should take input from your language's equivalent of STDIN and write the contents of the file to STDOUT (or equivalent). The program should close the file after the user is done with it (when they type 'q'). If the file does not exist, then the program should create a new one with the given filename. Editing is done line-by-line. The user gives the line number they wish to edit, and then give the new content of that line. If there is no content given, the line should be removed. Additional specifications are listed below.
## Commands
`filename?>` - opens the specified file. If a file with the given name can not be found, create a new file. If the user types `DELETE`, then the program should prompt with `delete?>`.
`delete?>` - "deletes" the file. This is done by blanking it (i.e. replacing its contents with `""`), which will suffice for this challenge. If the file can not be found, then print `FILE NOT FOUND`.
`line?>` - the given line number is where the text will be changed when `content?>` is given. If `q` is entered, then close the file and exit. If `a` is entered, then append a new empty line to the end of the file. If the index is out of bounds (i.e. does not exist (the text files can be `1` or `0` based indexed)) then print `Error!`.
`content?>` - input that is given here will replace that of the previous content of the line given earlier (`line?>`). If empty then delete that line (remove content from the line and shift all lines after it up one).
After each `filename?>` and `content?>` the contents of the file should be printed, as well as `--` followed by the number of lines in the file.
## Examples
A (rather bad) example program in Python3 can be found [here](https://repl.it/@Squrril/ExampleTextEditor).
Example deletions:
```
filename?>DELETE
delete?>passwords.txt
```
```
filename?>DELETE
delete?>evidence.txt
FILE NOT FOUND
```
Example run:
```
filename?>passwords.txt
password
admin
1234
********
p@$$w0rd
c0d3\_1$\_l!f3
--
6
line?>3
content?>12345678
password
admin
12345678
\*\*\*\*\*\*\*\*
p@$$w0rd
c0d3_1$_l!f3
--
6
line?>4
content?>
password
admin
12345678
p@$$w0rd
c0d3\_1$\_l!f3
--
6
line?>a
password
admin
12345678
p@$$w0rd
c0d3_1$_l!f3
--
7
line?>9
Error!
line?>1
content?>passcode
passcode
admin
12345678
p@$$w0rd
c0d3_1$_l!f3
--
7
line?>5
content?>
password
admin
12345678
p@$$w0rd
--
6
line?>q
```
Remember, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins!
[Answer]
# Bash, ~~388~~ 375 characters
Note that I am aware that further clarifications may come which will invalidate my solution.
Feel free to carry out any necessary modification in the requirement.
I posted this because the challenge is complex and may help to see how someone else understood it when editing for clarification.
```
set -f
IFS=
read -pfilename?\> f
[ $f = DELETE ]&&{
read -pdelete?\> f
[ -f $f ]&&>$f||echo FILE NOT FOUND
exit
}
[ -f $f ]&&mapfile t<$f
echo "${t[*]}--"
while read -plineno?\> l;do
[ $l = q ]&&break
[ $l = a ]&&t+=('
')||{ ((l>=${#t[@]}))&&echo Error!&&continue
read -pcontent?\> c
[ $c ]&&t[l]="$c
"||t=(${t[@]::l} ${t[@]:l+1})
}
echo "${t[*]}--"
done
echo -n "${t[*]}">$f
```
Thanks to:
* [GammaFunction](https://codegolf.stackexchange.com/users/86147/gammafunction) for suggesting `set -f` to make some quoting unnecessary (13 characters).
[Answer]
# Zsh, 309 bytes
```
p(){print -l - "$t[@]" -- $#t}
read f'?filename?>'
[ $f = DELETE ]&&{
read f'?delete?>'
[ -f $f ]&&:>$f||echo FILE NOT FOUND
exit}
[ -f $f ]&&t=("${(@f)"$(<$f)"}")
p
while read l'?lineno?>'&&[ ${l/q} ];do
[ $l = a ]&&t+=('')||{((l&&l<=$#t))&&read c'?content?>'&&t[l]=($c);}||echo Error!
p
done
<<<${(F)t}>"$f"
```
Compared to Bash, we use `[` instead of `[[`, get rid of unnecessary quotes (although many are still necessary due to `$foo` expanding to no words if `foo` is empty. We take advantage of this with the `array[index]=(a list)` syntax to insert in a new line *unless* `$c` is empty, in which case `t[l]=()` deletes it.
] |
[Question]
[
**This question already has answers here**:
[Print all ASCII alphanumeric characters without using them](/questions/105781/print-all-ascii-alphanumeric-characters-without-using-them)
(53 answers)
Closed 4 years ago.
You are tasked with displaying the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ" and only that, except for trailing newlines if they're unavoidable.
You must not output any homoglyphic characters like Cyrillic A. You can use non-Unicode encodings, but just to be sure, only output the Latin letters.
Regardless of the encoding you pick, you must not use the characters from U+0041 to U+005A or from U+0061 to U+007A in your source.
No other cheats or loopholes are allowed.
This is a code golf challenge, so the shortest answer wins. However, I won't pick a winner answer since the shortest answer might change over time.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 35 bytes
```
+++++++++++++[>++>+++++<<-]>[>.+<-]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGxlE22lr24FZNja6sXbRdnraQPr/fwA "brainfuck – Try It Online")
This is the first language I thought of because it is really good for no-letter no-number challenges lol.
[Answer]
# C64Mini/C64 BASIC (and other Commodore/CBM BASIC variants) 24 BASIC tokenized bytes used
In order to meet the criteria of "Regardless of the encoding you pick, you must not use the characters from U+0041 to U+005A or from U+0061 to U+007A in your source" (even though `Unicode` isn't a thing on the Commodore 64), you must enter this in "reverse mode" [`REVS ON`] by pressing `CTRL` or `Control` (or the equivalent on your emulator) and `9`.
In the screen shot, the screen codes for each character in my program is displayed after running it as I have read the memory from the start of screen RAM (top-left) (at 0x0400 or 1024) + 31 characters
```
0FORI=65TO90:?CHR$(I);:NEXT
```
Simply starts from the 8-bit `PETSCII` `A` through to `Z` printing the character code with the `CHR$` command [source](https://www.c64-wiki.com/wiki/CHR$)
[](https://i.stack.imgur.com/7E0V6.png)
] |
[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/180804/edit).
Closed 4 years ago.
[Improve this question](/posts/180804/edit)
Given a truth table and two images, use the truth table as a bitwise operation to the two images.
For example with the truth table:
```
1 0
1 0 0
0 1 0
```
(Note that the top is the first image and the left is the second)
and the two images `(0, 2, 4)` (a `1x1` image, with the numbers being RGB values) and `(30, 20, 10)`:
You would apply the above truth table to the numbers `0` and `30`, of which's binary representations are `00000` and `11110`.
Using the truth table as a bitwise operation would get us `00000`, or in decimal form `0`.
This means that the red value of the first pixel would be `0`.
Continuing this with the other RGB values would get us `2` and `4` for green and blue respectively.
So the output for this would be a `1x1` image with the only pixel having an RGB value of `0, 2, 4`.
For images greater than `1x1`, you apply the truth table for both corresponding pixels on both images and output it to the output image.
For example, if we had a pixel which is located at (x, y) in the image, you would apply the truth table to the R, G, and B values for the (x, y) position in the first image and the (x, y) position in the second. Once you have done this, the (x, y) position in the output image is the output of the truth table applied to the R, G, and B values.
**NOTES:**
You can use any default input or output method.
You can assume that the two input images are the same dimensions.
You can use any [Standard Image I/O](https://codegolf.meta.stackexchange.com/questions/9093/default-acceptable-image-i-o-methods-for-image-related-challenges) that supports RGB.
The truth table can be in any format you want.
As always, since this is code golf, **lowest byte-count wins**!
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 3 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Prompts for first image, then truth table, then second image, all from STDIN. Images must be given as bit arrays (for example, 8 × height × width × 3, but this doesn't actually matter). The truth table must be given as a Boolean APL function. *And yes, those are three identical boxes:*
```
⎕⎕⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKO94P@jvqkQBOJyPeqdq1CSkaqQlp@Tk1@emZeukJKalpmXWqyQqFBQlJ9elJiroFSopFCekZmcoZCRCBJPK8pMzUvJyUwtUvDU9wdqLcpNLLHiAhpXaJ2ZZ51fWsKVmfeobUL1o97OQys0LB71bjHSfNQx41HXkkMrHvVureUCKgHJGz3qWgoS6UQIawB19k3VBGIoC2TsfwUwKOAyVDAEGvaoq0nDQAEFaiqgiBiiiRiC1XABHbT1UQfQrl2POpbXAalaDBMNoRCh3xCuH2EiVEyTS1dXlwviuEKEUQYKRgomeC0zBioBmmAAAA "APL (Dyalog Unicode) – Try It Online")
`⎕` prompt for the first image
`⎕` prompt for the function, and apply it with the following left argument:
`⎕` prompt for the second image
] |
[Question]
[
# Challenge
Given an integer greater or equal to 4, n, print a rounded rectangle of as close as possible (with a gap of 1) sides and a perimeter of n characters.
# Rules
* n is always 4 or greater, because otherwise the output wouldn't be a square
* The characters for the perimeter can be any non-whitespace character
* The rectangle should have equal sides when possible
* When not possible, the rectangle can be up to one character taller or wider than its other side
* The rectangle should have one whitespace character in each corner
* The rectangle can only ever have a gap of 1 (excluding corners) along the entire perimeter
* The gap can be on any side and any position along the perimeter
# Rules
Least amount of bytes wins!
# Examples
```
Input: 4
Output:
o
o o
o
Input: 5
Output:
oo
o o
o
Input: 8
Output:
oo
o o
o o
oo
Input: 21
Output:
oooooo
o o
o o
o o
o o
o o
ooooo
```
Here is the python3 code I used to generate the above examples:
>
>
> ```
> import math
>
> ch = 'o'
>
> def print_rect(p):
> side_length = math.ceil(p / 4)
> height = side_length
> remainder = p - side_length * 3
> p = side_length + 2
>
> if side_length - remainder >= 2 or not remainder:
> remainder += 2
> height -= 1
>
> lines = [(ch * side_length).center(p)]
> for i in range(height):
> lines.append(ch + ch.rjust(side_length + 1))
> lines.append((ch * remainder).center(p))
>
> print('Output:')
> for line in lines:
> print(line)
>
> print_rect(int(input('Input: ')))
> ```
>
>
>
>
[Answer]
# [Python 2](https://docs.python.org/2/), 91 bytes
```
def f(n):t=(n+3)/4;c,s='o ';h=(n-t+1)/3;print'\n'.join([s+c*t]+[c+s*t+c]*h+[s+c*(n-t-h-h)])
```
[Try it online!](https://tio.run/##HY0xEoMgEAB7X3EdnCdxxFQyvsRQZIgEUhwO0OT1xNjuzO4e3xoS69ZeuwcvGZe6SqYZx7txQ1lFAmHCiVSlCcfZHDlyFQ8Wt0@KLLdCrq@WNkelr@RsH@hif0MFFdBi8ylDhMiQn/ze5TRojUt37iJ2cAXbDw "Python 2 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 24 bytes
```
Ｆ⁴«×o⁺÷Ｉθ⁴﹪÷﹪Ｉθ⁴Ｘ²↔⊖鲶↷
```
[Try it online!](https://tio.run/##VU09C8IwFJz1V4RMrxAHSzcnsYuDEMTRpTZP@yDNwySNg/jbYxQFPTiO@4Drh8733Nmcz@wFNJW4z2fak4twoBEDSJZKaDsF2LrYUiKDsOlChGulRFO4YzNZ/mk/wd9I8w091EqsTwFa7D2O6CIaoKpAifolq@@zPDr5dpQ47ukyRCj2kXO9zItknw "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｆ⁴«
```
Loop over the four sides of the rounded rectangle.
```
×o⁺
```
Print a number of `o`s given by the sum of...
```
÷Ｉθ⁴
```
... one quarter of the input as a number, rounded down, and...
```
﹪÷﹪Ｉθ⁴Ｘ²↔⊖ι²
```
... add an extra `o` a) on both horizontal sides if the input has a remainder (modulo 4) of 2 or 3, and b) on the first vertical side if the input is odd.
```
¶
```
Omit the corner.
```
↷
```
Pivot ready for the next side.
[Answer]
# JavaScript, 143
```
n=>(x=Math.floor(n/4),q=n%2==1?x+1:x,` ${"o".repeat(q)}
${Array(n%4==2||n%4==3?x+1:x).fill(`o${" ".repeat(q)}o`).join`\n`}
${"o".repeat(x)}`)
```
] |
[Question]
[
Given a number `n`, calculates `BB(n)` (the maximum number of `1`s finally on the tape, among all halting 2-symbol n-state Turing machines with tape of zeros).
To solve the problem, you are given an extra ([black-box](https://codegolf.meta.stackexchange.com/a/13706)) function **H** as input, which takes a function in your language (**f**) and returns a truthy/falsy value indicates whether this function will halt. However, the function **f** must not have any side-effects (I/O operations, timing, etc.) or call the halting function **H**.
Note that, there is no restriction on how you use the function **H**. A possible way is to use the function **H** to check if each Turing machine halts, and then simulate those to calculate the maximum, but there are other ways to compute `BB(n)`.
You need to prove that it solves such a problem. Shortest code in bytes wins.
Definition of Turing Machine:
```
Turing machines, each member of which is required to meet the following design specifications:
The machine has n "operational" states plus a Halt state, where n is a positive integer, and one of the n states is distinguished as the starting state. (Typically, the states are labelled by 1, 2, ..., n, with state 1 as the starting state, or by A, B, C, ..., with state A as the starting state.)
The machine uses a single two-way infinite (or unbounded) tape.
The tape alphabet is {0, 1}, with 0 serving as the blank symbol.
The machine's transition function takes two inputs:
the current non-Halt state,
the symbol in the current tape cell,
and produces three outputs:
a symbol to write over the symbol in the current tape cell (it may be the same symbol as the symbol overwritten),
a direction to move (left or right; that is, shift to the tape cell one place to the left or right of the current cell), and
a state to transition into (which may be the Halt state).
There are thus (4n + 4)2n n-state Turing machines meeting this definition.
The transition function may be seen as a finite table of 5-tuples, each of the form
(current state, current symbol, symbol to write, direction of shift, next state).
```
[Answer]
# [Perl 5](https://www.perl.org/), ~~149~~ 147 bytes (+15 bytes if you want to be really strict)
Generates all Turing machines, use H as oracle to see if they halt and if so runs them, count the number of `1`s and take the maximum
```
#!/usr/bin/perl -p
$"=",",@t=1..$_;map{H($f=sub{my%v;$v{$n}=$1while/(A?)(\d+)(\W)$2$v{$n+=$3.1}/;map/A/,%v})&&\$G[&$f]}glob join"V{,A}{@t,0}{+,-}",0,<{@t}{,A}>;$_=$#G
```
Slightly breaks the conditions on `f` though not in an very bad way.
* `$n` is the starting position on the tape and is a global. So on each new run it starts where the previous Turing machine left off. But since the tape state ***is*** local and starts empty it doesn't matter where you start, so it's not actually used to communicate anything (adding `$n` to the `my` solves that at a cost of 5 bytes)
* I pass the actual Turing machine in global `$_`. That's also easily solved by e.g. a `for` loop over `my` variable `$g` and use it in `$f` via closure with `while$g=~/.../` at the cost of 10 bytes. However the current way has the advantage that I can also see `$_` inside `H` and return true for a few halting Turing machines so that I can really compute BB(1) and BB(2) and BB(3) (BB(3) takes 90 minutes on my computer)
[Try it online!](https://tio.run/##tVVLb9pAEL7zK6ZmE9mxwQ@US4zTEKlNDq1atRE9YIKcZCFu/RK70BBwf3rp7Jq3oUkPXWG8nvnm9Xl2nNFhdDonM892K/EESH8UReBB87x4jALGPavYx8FTT@iWe7qxt3C/gF1eekoFcFnQhpal29Du3La7J/DCqoINjAecwuXl2t4R9nir2S1xt2tOG306rX32zmF7Wy/sGyt7KWwUvhstad9Y2ytuRRTyi5k@O6nWT0xzsJJ0bv2vftLdFPm66eM1WDLQ45RxpOR7GiaqMlMMYFkUclAAt6jX3Aob3cE1TGWmD2lxF0s4eEbTMOEqD2OqaqZtIX6pD/ugIuCNV7wcDdamYrFgAsrnYToYUsaA9BRhIJHuFk6KMAx5Xsvz7SCyFTCOtRsjSu@DCIjiYTluOfqXUZKEyWAVXPppivbYhGKd6hGjNDEueJBR42hskFjbSbIqVJilUza@uEG5ihlo8ATSRQlCElGg9GE629qfj2FEQTXV1ltN9R90/PumEYcIbIckukcadbtr7lYulq6T2C1Jl5ZdEdLeo79ZKWE2A8VC5kqgNe3NMutl9hV3L0C@BGL7nDh4NfBKfH5xswedH0hBvJapIkkVJBJHyXX9UD5VbNV@mIR4cKI0zfZipNcYzpdDBBl4sc5VKR/QKxP22pnoKfcgejWh9r2g7QbfXEPKR8Nktz/342Uh2FZ4KmQRclu02GF@Po04pH24S0fJA6vD@3QILA6w@ji4fwwTyoA/hgzwF4U/aDSB4LVM0n9j8h27DzJxNF9LJv1vZG4/VeE6iDgrHeBUkOMBDrMMzJZp7DnnkhCJW3CSvsiJ5EIGXJiah@lYuPSKXNy/1LCofOPs50AjRncSWMDMW/Xt2fJLoRFzdwrnlbwyF4fcULBqz67XSc@Ng2x6jRPCw4/HNJ4cjV0ynpIk94gtB1ppnAltMctyU1gLDo/GuXZ87JOrzjHpd/NBlN7J75TSnhqtfHrBDSuf6kYtVwzLaOJzLuTnLul5pHo1nzu/04yHacLmtWxe@3hat6269Qc "Perl 5 – Try It Online")
The TIO link implements an actual (sort of) halting function in the header.
* The default version has the actual size 1 to 3 busy beaver hard-coded and returns true only for that particular Turing machine. All others return false
* If you add a `1` on the next input line after the size then `H` will be a real halting function but only for a tape that runs from `-10` to `10`. It will return false for any Turing machine that repeats its complete state or reaches the edge of the tape (so 19 tape positions can actually be used). It returns true for any Turing machine that halts on this restricted tape. This is enough to ***really*** calculate BB(1), BB(2) and BB(3) (you'll need lots of patience and memory for BB(3) but it does work). It also prints out some info about long running machines it finds along the way.
* If instead you add `-1` on the next input line after the size then `H` will behave like what is described for extra argument `1` but will also show the full execution trace of every Turing machine it tries.
Each Turing machines is represented by a strings that describe all input tuples with their corresponding output state. A tape value is either `A` (for `1`) or empty (for `0`). The states are numbered from `1` to `n`, `0` is the halting state. A tuple is the concatenation of:
```
value to write to tape (A or empty)
new state (1 to n or 0)
direction to move the head (+ or -)
input state (1 to n)
input tape value (A or empty)
```
The full string consists of a dummy `0` and then `2n` tuples in increasing order all separated by `V`. So for example a 2 state busy beaver Turing machine in this notation is:
```
0VA2+1VA2-1AVA1-2VA0+2A
```
which represents these 4 tuples:
```
A2+1 in state 1 seeing 0, write 1 move right go to state 2
A2-1A in state 1 seeing 1, write 1 move left go to state 2
A1-2 in state 2 seeing 0, write 1 move left go to state 1
A0+2A in state 2 seeing 1, write 1 move right go to state 0 (halt)
```
] |
[Question]
[
Christmas is [coming up](https://www.yourchristmascountdown.com/), and this year you have been charged with organizing your family's christmas get-together. You have a list of foods you want be there, but before you assign foods to people, you need to know who's coming. So...
# Challenge
Given an input of relative's names separated by commas or whatever (note that the names may have spaces in them, e.g. "Aunt Gertrude") and a list of meals including turkey, divide the meals among them equally, but saving the turkey and any extra for yourself, because you don't want to be unfair. In other words, if 6 people are coming and there are 10 meals, you have to do the turkey and 3 others, because 6 goes into 9 once, leaving 4 for you.
Input will never have more people than meals.
# Full list of possible dishes ([Taken from Wikipedia](https://en.wikipedia.org/wiki/List_of_Christmas_dishes#United_States))
```
Apple Cider
Boiled Custard
Candy canes
Champagne
Chocolate fudge
Christmas cookies
Cranberry sauce
Eggnog
Fish
Fruitcake
Gingerbread Men
Christmas ham
Hot buttered rum
Hot chocolate
Mashed potato
Mixed nuts
Oyster stew
Persimmon pudding
Apple pie
Pecan pie
Pumpkin pie
Sparkling cider
Stuffing
Sweet potato pie
Sweet potato casserole with marshmallow
Russian tea cakes
Tom and Jerry
Turkey
Here is a formatted version if you prefer:
["Apple Cider","Boiled Custard","Candy canes","Champagne","Chocolate fudge","Christmas cookies","Cranberry Sauce","Eggnog","Fish","Fruitcake","Gingerbread Men","Christmas Ham","Hot buttered rum","Hot chocolate","Mashed potato","Mixed nuts","Oyster stew","Persimmon pudding","Apple pie","Pecan pie","Pumpkin pie","Sparkling cider","Stuffing","Sweet potato pie","Sweet potato casserole with marshmallow","Russian tea cakes","Tom and Jerry","Turkey"]
```
# Name format
Relative's names will take any of the following formats
```
Aunt x
Uncle x
Creepy Uncle x
Grandpa x
Grandma x
Cousin x
Mother-in-law x
Father-in-law x
Papa x
Nana x
x
x can be any 20 char or less combination of upper/lower case letters
```
# I/O
**Input** can be taken in any reasonable, convenient format, but I will assume list if not otherwise specified: [relative a,b,c],[food x,y,z]
**Output** can also be in any reasonable convenient format, I personally prefer a list of lists You do **not** need to output the turkey or extra meals
# Examples
```
["Aunt Gertrude", "Cousin Sally", "Grandpa Joe", "Creepy Uncle Rick"],["Sparkling Cider", "Pumpkin Pie", "Pecan Pie", "Oyster Stew", "Chocolate Fudge", "Turkey"] -> [["Aunt Gertrude","Sparkling Cider"],["Cousin Sally", "Pumpkin Pie"],["Grandpa Joe","Pecan Pie"],["Creepy Uncle Rick","Oyster Stew"]]
["Aunt getoFFmyLAWn","Grandpa Lipbalm","Cousin onlyplaysroblox","Papa losthisjob"],["Pumpkin pie","Sparkling cider","Stuffing","Sweet potato pie","Sweet potato casserole with marshmallow","Russian tea cakes","Tom and Jerry"] -> [['Aunt getoFFmyLAWn', 'Pumpkin pie'], ['Grandpa Lipbalm', 'Sparkling cider'], ['Cousin onlyplaysroblox', 'Stuffing'], ['Papa losthisjob', 'Sweet potato pie']]
```
As christmas is almost here, you don't have time to be planning more than needed, so use those [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") skills and program up some lists!
# Notes
* No standard loopholes
* If you have only a function, please provide code to call it as well
* Please provide an explanation
* Smallest byte count ~ 2-3 days after Christmas wins!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 17 bytes
I went off-piste with the meals in my example without realising! It shouldn't matter I think, and looks tastier to my British eyes.
```
ḟ“Øẇ½»W¤s⁹L‘¤ṖZṖż
```
A dyadic link taking a list of foods (lists of characters) on the left and people (also lists of characters) on the right which returns a list containing a list per person containing a list of characters (their name) and a list of foods (each a list of characters).
e.g. (using `"..."` to represent a list of characters):
```
left = ["Champagne", "Turkey", "Stuffing", "Port", "Roast Potatoes", "Brussel Sprouts", "Parsnips", "Pigs In Blankets", "Gravy", "Steamed Vegetables", "Cheese Plate", "Christmas Pudding"]
right = ["Aunt Gertrude", "Cousin Sally", "Grandpa Joe"]
output = [[["Champagne", "Brussel Sprouts"],"Aunt Gertrude"],[["Stuffing", "Parsnips"],"Cousin Sally"],[["Port", "Pigs In Blankets"],"Grandpa Joe"]]
(leaving us with Turkey, Roast Potatoes, Gravy, Steamed Vegetables, and Christmas Pudding.)
```
**[Try it online!](https://tio.run/##LVC9TsNADH4VK3MXVjbaoQIxRASBAHUwipteermLzndI3VoW3gBVCImlgoUHIPwNqfogyYuEC9fB9vd9tvxZzknKRdc1Hy/t8nm7bj4f6p/667LecLuqTtvlut401eO1j913t33zYt7evx/Urz63q98BNNWTh3mgh3DVdTfRaIZFiZmiaADRuTNzWvQosW46FSrrcayN7euZRrYQa4tWE/fK0DhmkpCURjv7L8VoWIkyYJExHCsYSlRzCv2xwbu9A2FBKVxQRhZvZdg4mhExQSzRUuBGsC2QIXZp2h808UcfOWVhTMYal4Yx7VgoSNB/aO@i0hLhRFM0@QM "Jelly – Try It Online")** (The footer calls the dyadic link and then pretty prints the result)
### How?
```
ḟ“Øẇ½»W¤s⁹L‘¤ṖZṖż - Link: foods, people
¤ - nilad followed by link(s) as a nilad:
⁹ - chain's right argument, people
L - length
‘ - increment (add yourself to the cook count)
¤ - nilad followed by link(s) as a nilad:
“Øẇ½» - compressed string = list of characters, ['T','u','r','k','e','y']
W - wrap in a list [['T','u','r','k','e','y']]
ḟ - filter discard (from foods) if exists in that list (we cook any Turkey)
s - split (the resulting list of foods) into chunks (of number of cooks)
Ṗ - pop off the excess
Z - transpose to a list of fair shares
Ṗ - pop off our share
ż - zip with people names (to provide the allocations)
```
[Answer]
# [Operation Flashpoint](https://en.wikipedia.org/wiki/Operation_Flashpoint:_Cold_War_Crisis) scripting language, 155 bytes
```
f={t=_this;a=t select 0;b=(t select 1)-["Turkey"];i=0;d=count a;e=count b;c=e/d;c=c-c%1;while{i<c*d}do{a set[i%d,(a select i%d)+","+(b select i)];i=i+1};a}
```
**Call with:**
```
array = [["Aunt Gertrude", "Cousin Sally", "Grandpa Joe", "Creepy Uncle Rick"],["Sparkling Cider", "Pumpkin Pie", "Pecan Pie", "Oyster Stew", "Chocolate Fudge", "Turkey"]];
hint format["%1", array call f]
```
**Output:**
[](https://i.stack.imgur.com/sTIgJ.jpg)
[Answer]
# PHP, 112 bytes
```
function($p,$f){return array_combine($p+[($n=count($p))=>0],array_chunk(array_diff($f,[Turkey]),count($f)/$n));}
```
anonymous function, takes an array of people and an array of meals,
returns an associative array `name=>array of meals` plus one element `0=>extra meals` (without the Turkey).
[Try it online](http://sandbox.onlinephpfunctions.com/code/bd9375a184528d6fe4787c5fe5617c3837406c1c).
] |
[Question]
[
**This question already has answers here**:
[Output a googol copies of a string](/questions/97975/output-a-googol-copies-of-a-string)
(85 answers)
Closed 6 years ago.
**Main objective**
The main objective is to output a text, it doesn't mind which text or where the text gets its output (it can be on a browser window, the default console etc).
It just requires the condition that what is output must be indeed "real chars" (the ones in UNICODE for example), it's not considered valid to display graphics that simulate chars.
**Condition to program**
Now into the conditions to program:
None of the characters that appear in the code must appear in the output.
The created string cannot be infinite (continuosly being created in a loop without end)
**Test cases**
So let's say that you code is
```
abcdef
```
If that displayed
```
ghijk
```
The code would be valid, but if this displayed:
```
chiij
```
Then it would not be valid
Obviously something like
print("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
That displays
```
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
```
would be invalid.
**Challenge**
Write a code that displays a text as defined.
**Scoring**
In this [code-challenge](/questions/tagged/code-challenge "show questions tagged 'code-challenge'"), your answer is scored by the ratio between string length and number of bytes in code (string length / code length), where the highest score wins.
Good luck!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 0 bytes, score: 1/0 = ∞
```
```
[Try it online!](https://tio.run/##y0rNyan8DwQA)
That's right, the empty program in Jelly prints `0`.
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page), score: 1000.6
```
⁶³ȷ³x
```
[Try it online!](https://tio.run/##y0rNyan8//9R47ZDm09sP7S54v9/AA)
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes, score: 95 / 2 = 47.5
```
ØṖ
```
[Try it online!](https://tio.run/##y0rNyan8///wjIc7p/3/DwA "Jelly – Try It Online")
This yields the set of all printable ASCII: `!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~` and a space (95 bytes)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 1 byte, score: 26
```
G
```
[Try it online](http://pyth.herokuapp.com/?code=G&debug=0)
This outputs: `abcdefghijklmnopqrstuvwxyz` (26 bytes).
[Answer]
# [Python 2](https://docs.python.org/2/), 14 bytes, score 27672892.1429
```
print"\n"*9**9
```
Prints 387420490 newlines. Output truncated on TIO.
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EKSZPSctSS8vy/38A "Python 2 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 91 bytes, score = 67067/91 = 737
```
s="s=forinage(35,127):chtp*0"
for f in range(35,127):
if chr(f)not in s:print(chr(f)*1000)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v9hWqdg2Lb8oMy8xPVXD2FTH0Mhc0yo5o6RAy0CJCyihkKaQmadQlJiHJM2lkJmmkJxRpJGmmZdfApIvtioAGlGiARHUMjQwMND8/x8A "Python 3 – Try It Online")
[Answer]
# cQuents, score: 1.8530202E33 / 9 bytes = 2.0589113E32
```
#9^8e9::n
```
Score is based on math, not runs of the program.
Prints `43046721000000000` copies of `43046721000000000` joined on `,`.
## Explanation
```
#9^8e9 n = (9^8) * 10^9
:: Print the sequence from 1 to n
n Each item in the sequence equals n
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/X9k4zjjV0soq7/9/AA "cQuents – Try It Online") (truncated)
] |
[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/110390/edit).
Closed 7 years ago.
[Improve this question](/posts/110390/edit)
Make a function, method, program or routine that will accept two interger parameters (say `x` and `y`) and the total of the two values multiplied. Except straight multiplication is not allowed so you must not simply do something like:
```
int multiply (int x, int y) {
return x*y;
}
```
Also you must not use a `for ()` loop, like this:
```
int multiply (int x, int y) {
int z = 0;
for (int i = 0;i < y; i++){
z += x;
}
return z;
}
```
Everything else is up to you. A winner is you with the most compact solution.
[Answer]
# Mathematica, 12 bytes
```
Exp@*Tr@*Log
```
Pure function taking a list of numbers (even complex numbers) as input and returning a number. Takes the logarithm of all the numbers in the list, adds them together, and exponentiates the result. Rules of exponents and logarithms ftw! (And because Mathematica calculates `Log[0]` as `-∞` and can subsequently manipulate that symbolically, it arrives at the correct answer if one input number equals `0`.)
# Mathematica, 24 bytes
```
Tr[1^Flatten@Array[,#]]&
```
Pure function taking a list of nonnegative (unfortunately) integers as input and returning their product. Simply creates an array of the appropriate dimensions and counts the number of entries (using `Tr[1^...]` as a golfy shorthand for `Length@...`). Since we don't care what's actually in the array, we can fill it with `Null`s using `Array[,#]`, which doesn't cost any bytes for the first argument.
[Answer]
## Ruby, 27 bytes
```
->i,j{(j!=0)?(i/(1.0/j)):0}
```
[Answer]
## Ruby, 22 bytes
```
->a,b{eval ?a<<42<<98}
```
Maybe bending the rules? This is no "straight" multiplication.
[Answer]
# [Perl](https://www.perl.org/), 19 bytes
18 bytes of code + `-p` flag.
```
s/.*/"$&+"x<>.0/ee
```
[Try it online!](https://tio.run/nexus/perl#U1YsSC3KUdAt@F@sr6elr6Sipq1UYWOnZ6Cfmvr/vymXGQA "Perl – TIO Nexus")
It takes two numbers (say `m` and `n`) and converts them into `m+m+...+m+0` (n times) and evaluates this string. (the final `+0` is to make sure that if one of the number is `0`, then the result is `0` and not an empty string)
[Answer]
# Python, ~~48~~ 39 bytes
-9 bytes thanks to @ovs
```
f=lambda x,y,t=0:x and f(x-1,y,t+y)or t
```
Recursively adds `y` to `t`, and returns the sum of `t` when x is 0.
] |
[Question]
[
# Chained Binary Operations
Here's a challenge involving [truth tables and binary operations](https://en.wikipedia.org/wiki/Truth_table). For this specific challenge, your task is to use the following table of operations:
[](https://i.stack.imgur.com/y1rjR.png)
To create a function that takes in two inputs `f(p,a)`, where `p` is the initial truthy/falsy value and `a` is a list of tuples representing multiple values of `q` and the operations to be performed. For instance, `f(T,[[T,0],[T,1]])` would return `ContradictionOP(T,T)=F`. You would then chain the output of this result into the next operation, which would be `LogicalNOR(F,T)=F`, where the 2nd `p` is the previous output of `F`. The final result being `false`. A better breakdown of what each operation actually is is described below:
[](https://i.stack.imgur.com/lsqqE.png)
The first part should be rather simplistic in nature, as the operators are arranged in an increasing binary pattern (hint, hint). However, recursing through the additional inputs to chain binary operations is probably the harder part to accomplish.
# Examples:
```
f(T,[])=T
f(F,[[F,15]])=T
f(T,[[F,15],[T,0],[F,6]])=F
f(T,[[F,15],[F,14],[F,13],[F,12],[F,11]])=F
```
# Extrapolated Example:
```
f(T,[[F,15],[F,14],[F,13],[F,12],[F,11]])=F
[T,[F,15]]=T*
[T*,[F,14]=T*
[T*,[F,13]=T*
[T*,[F,12]=T*
[T*,[F,11]=F
FALSE.
```
# Rules:
* You MUST use the order specified for the operations as stated above.
* The input format for `a` can be a 2D array, array of tuples, command line pairwise arguments or any other representation of pairs of boolean/operations. Could even be a single array that you parse pairwise.
* You may use `0` for `false` and `1` for `true`, it is **not** acceptable to reverse the two.
* The output should be simply a truthy or falsy value.
* No loopholes, this is code-golf, standard CG rules apply.
**Example Single Iteration Algorithm:**
```
f={
p,q,o->
op=Integer.toBinaryString(o); // Calculate the binary OP string (15=1111)
binaryIndex="$p$q" // Calculate binary combination of p/q (T/F=10)
i=Integer.parseInt(binaryIndex,2) // Convert to decimal index (T/F=2)
op.charAt(i) // Get the binary char at the calculated index (T/F/15=1).
}
f(1,0,15) // "1"
```
[Answer]
## JavaScript (ES6), 34 bytes
```
a=>a.reduce((l,[r,o])=>o>>l+l+r&1)
```
Accepts true/false but prefers 1/0 format.
[Answer]
## CJam (15 bytes)
```
{{+)2@2b#/1&}/}
```
[Online demo](http://cjam.aditsu.net/#code=%5B%0A%20%20%5B1%20%5B%5D%5D%0A%20%20%5B0%20%5B%5B0%2015%5D%5D%5D%0A%20%20%5B1%20%5B%5B0%2015%5D%20%5B1%200%5D%20%5B0%206%5D%5D%5D%0A%20%20%5B1%20%5B%5B0%2015%5D%20%5B0%2014%5D%20%5B0%2013%5D%20%5B0%2012%5D%20%5B0%2011%5D%5D%5D%0A%5D%7B~%0A%0A%7B%7B%2B)2%402b%23%2F1%26%7D%2F%7D%0A%0A~o%7D%2F). This is an anonymous block (function) which takes the two values on the stack and leaves the result on the stack.
### Dissection
```
{ e# Define a block:
{ e# For each pair in the array...
+)2@ e# Prepend the accumulator, pop the op, push a 2, and rot 3
e# Stack is now: op 2 [accum arg]
2b# e# Find 2**(2*accum + arg)
/1& e# Test the corresponding bit of op, setting it as the new accum
}/
}
```
] |
[Question]
[
The new xkcd feed bot room gave me an idea for a simple challenge.
Your code will have to monitor the xkcd website and output all the new comics to the user.
# Specs
* When first run it should just sit around waiting.
* Then, when randall posts a new comic, within a minute, it should display the new comic in any of our usual standards for images (display, save, etc.)
* If the comic is interactive and not a simple image, then print out the string `"interactive comic"`.
* This does not include the comics which are an image inside a link, those still have to be displayed normally.
* After displaying the image, it should go back to waiting around for the next update.
* Your program cannot access any sites except <http://xkcd.com>
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code in **bytes** wins!
[Answer]
## PowerShell v2+ & Default Browser, ~~215~~ 217 bytes
```
$l=date;for(){if(($x=([xml](iwr xkcd.com/rss.xml)).rss.channel.item[0]).pubdate-ge$l){if(($y=$x.description)-match'img src'){saps ($y-replace'<img src="'-replace'" .*')}else{echo "interactive comic"}}$l=date}
```
***WARNING:*** Running this as-is will likely make Randall very mad at you, due to the high frequency of calls to the RSS feed ... **so, y'know, don't do that.** (See below for an alternate version that can be used in a one-off manner)
Sets the `$l`ast time we displayed a comic to the result of `Get-Date`. Then, enter an infinite `for` loop.
Each iteration, we `iwr` (alias for `Invoke-WebRequest`) the RSS feed for the site. That's parsed as `[xml]` (yes, PowerShell can cast as XML), and the `.rss.channel.item[0]` thereof (i.e., the newest) is stored in `$x`. If the `.pubDate` is `-ge$l` (i.e., newer than the last comic we showed), we have a new comic to display.
So, we first check the `.description` field (saved in `$y`), to see if it matches `img src`. If so, we parse out the img from `$y`, and feed that to `saps` (alias for `Start-Process`). Since it's a URI, this relies on Windows' default behavior for "executing" a URI, that is, it opens the default browser to that location. (*If this is too cheaty, let me know and we can `iwr` down the actual image and save it.*)
Otherwise, we `echo` out that we've got an `interactive comic`.
In either case, we update our `$l` date to "now" since we just displayed a comic.
*Saved 7 bytes thanks to Matt for reminding me that `http://` can be implied*
---
### "Safe" version that executes just once and displays the latest comic
```
$l=(date).AddDays(-3);if(($x=([xml](iwr http://xkcd.com/rss.xml)).rss.channel.item[0]).pubdate-ge$l){if(($y=$x.description)-match'img src'){saps ($y-replace'<img src="'-replace'" .*')}else{echo "interactive comic"}}
```
You can run this one safely to see how the logic works. It'll only execute once and only display the latest comic.
] |
[Question]
[
**This question already has answers here**:
[Time-Sensitive Echo](/questions/60188/time-sensitive-echo)
(20 answers)
Closed 8 years ago.
A simple code golf challenge similar to [an already existing, but more complex one](https://codegolf.stackexchange.com/questions/60188/time-sensitive-echo):
1. Wait for user to press enter.
2. Wait for user to press enter again.
3. Print the elapsed time between the 1. and 2.
4. Wait an equal amount of time
5. Print the actual elapsed time of 4.
Order of 3. and 4. is not important. Notice that the second printout entails actual timekeeping during the machine's delay; just outputting the desired delay is not enough.
The time outputs should be in seconds, with at least 10 ms resolution.
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 14 bytes
This answer uses the current version of the language ([3.1.0](https://github.com/lmendo/MATL/releases/tag/3.1.0)), which is earlier than the challenge.
```
jY`jZ`tDY`Y.Z`
```
### Example
I tried to wait for about 1 second:
```
>> matl jY`jZ`tDY`Y.Z`
>
>
1.011063770698121
1.013172086910349
```
### Explanation
```
j % input string (will be empty)
Y` % start a stopwatch timer
j % input string (will be empty)
Z` % read the stopwatch timer and push the value onto the stack
tD % duplicate, convert to string and display
Y` % start a stopwatch timer (this doesn't produce any output)
Y. % pause the specified amount of time (which is at the top of the stack)
Z` % read the stopwatch timer (will be implicitly displayed)
```
[Answer]
# R, 87 bytes
### code
```
f=readline;s=Sys.time;f();q=s();f();e=(m=s())+(z=(m-q));while(s()<e)1;cat(z,"\n",s()-m)
```
### example
```
> f=readline;s=Sys.time;f();q=s();f();e=(m=s())+(z=(m-q));while(s()<e)1;cat(z,"\n",s()-m)
> 1.343448 # 1 second wait plus 0.3s mental lag
> 1.358646
```
[Answer]
## Matlab: 44 bytes ##
```
input('');tic;input('');t=toc
pause(t);toc-t
```
Output
```
t =
1.8318
ans =
1.8338
```
Explanation: `input('')` wait for enter, `tic` starts timer, `t=toc` display
[Answer]
# Bash + GNU utilities, 63
```
d=0
f(){ read;d=`date +%s.%N-$d|bc -l`;}
f
f
bc<<<$d/1
sleep $d
```
[Answer]
## Mathematica, 71 bytes
```
(b=InputString)[];a=(c=Print@*First)@(d=AbsoluteTiming)@b[];c@d@Pause@a
```
Needs to be run in v10.3 or higher. Good thing that symbols are first-class objects...
] |
[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/58654/edit).
Closed 8 years ago.
[Improve this question](/posts/58654/edit)
Create a program that does the same thing forwards and backwards, in **different languages**. “Different languages” does not include different versions of the same language.
## Challenge
This program can take any input and write anything to stdout and stderr.
However, the program must output *exactly the same* things for the same input when run backwards in the other language. This explicitly includes anything written to stderr **while the program is running**, including errors. The length of the output from stdout and stderr must sum to at least 5. The minimum program length is 2 bytes.
* This is a [popularity-contest](/questions/tagged/popularity-contest "show questions tagged 'popularity-contest'"), so the answer with the most votes wins.
* Comments are allowed, however the commented text must take up less than ¼ of the total program.
[Answer]
# BF + Foo
You saw it coming
```
-[------->+<]>-.-[->+++++<]>++.+++++++..+++."olleH"
```
] |
[Question]
[
All those questions that are duplicates... Ignored and marginalized by society. It is just not... right. We have to do something. There surely must be love for them too.
They feel appreciated if a piece of code outputs a link to a duplicate question. But the duplicate questions are not so easily impressed. They are swept out off their feet only when the code when duplicated outputs a link to another duplicate question. The more the code can be duplicated and still output these links, the more the questions feel more loved.
Your task is to bring love and appreciation to these Stack Exchange pariahs.
---
Create a piece of code that when duplicated `k` times outputs a link to a duplicate question. `k` represents all the numbers in range `[1, N]`.
**Edit** I made code size matter because I realized you can write a program that can output as many links as you wanted.
# Rules:
**Language:**
* any language created prior to the post of this challenge is accepted. You may use a language already used in another answer.
* you may **not** use external resources (a database etc.)
* any encoding and any characters are allowed (including white spaces, new lines, non-ASCII). ~~Encoding is UTF-8.~~
* ~~code size does not matter~~. Size is measured in bytes.
* all duplications must be in the same language
**Code duplication:**
* ***clarification:*** the code must not duplicate itself. Simply put duplicating here means creating another code by copy-pasting the original one at the end of the last one obtained. Each will result in a new code that is run independently from the others.
* all the characters in the original code must be copy-pasted (including trailing new line (if any)). Each time the code pasted must be appended at the end.
* the code must create valid output when duplicated `1 (no duplication), 2, 3, 4, 5... N times`.
* It cannot skip a number (e.g. a code that creates valid output only when duplicated `1, 2, 3, 5, 6 times` will be considered only for `1, 2, 3` so `N = 3`)
* each time exactly one link must be output-ed.
* example (for what duplication means, not for valid output)
(python3) Original code (k = 1):
```
try:
i
except NameError:
i = 100
else:
i = 200
if i == 100:
print("stackoverflow.com/questions/" + str(i),end="")
else:
print(i)
```
>
> k = 1 outputs stackoverflow.com/questions/100
>
> k = 2 outputs stackoverflow.com/questions/100200
>
> k = 3 outputs stackoverflow.com/questions/100200200
>
>
>
**Duplicate questions links (valid output):**
* Non-deleted questions from [Programming Puzzles & Code Golf](https://codegolf.stackexchange.com/) and [Stack Overflow](https://stackoverflow.com/) that were closed as duplicate prior to the time of the posting of this post are considered for this challenge.
* Helpful query to search for duplicate questions:
>
> is:question duplicate:yes
>
>
>
[duplicates on PPCG](https://codegolf.stackexchange.com/search?q=is%3Aquestion%20duplicate%3Ayes) and [duplicates on SO](https://stackoverflow.com/search?q=is%3Aquestion%20duplicate%3Ayes)
* Link format. Lets take as an example this post:
<https://stackoverflow.com/questions/1066589/iterate-through-a-hashmap>
A valid link output for this question is any of these the two base links
```
stackoverflow.com/questions/1066589
stackoverflow.com/q/1066589
^~~~~~^
this is referred as the link number in following paragraphs
```
to which you may add the prefix(es) `www.` and/or `http://`. You may also add a trailing `/`
Please note that after that you must not add anything (like the question title), even if that link results in a redirect to the question.
* You may not use a URL shortner service.
* You may not link to an answer or to another part of the page.
* The questions don't have to be duplicates of the same original or related in any way (`don't have to` means they can be if you want).
* For each time (for each `k`) a different question must be linked (two different links to the same question count as the same question)
**Multiple Submissions**
* You may post multiple answers with the same or different languages. Different posts can output the same link.
# Scoring
* Each link gives **1 point**.
* **Egoistic bonus**: **+0.5 points** for each link to your own question.
* **Forgive me bonus**: **+0.5 point** for each link to a question you voted to close (for whatever reason).
* **Judge Jury Executioner bonus**: **+0.5 point** for each link to your own question that you yourself voted to close (for whatever reason).
* **now what bonus**: **+0.5 points** for each link to a question closed as a duplicate to a question that has no answers.
* **train of thought bonus**: **+1 point** for each link to a question closed as a duplicate to another duplicate question (regardless of the length of the train)
* **dead end bonus**: **+1 point** for each link to a question closed as a duplicate of a question that was closed for a reason other than duplicate. (locked questions that exists because they have historical significance also don't count for this bonus).
* **George Santayana bonus**: **+1 point** for each link closed as a duplicate of a question by the same user.
* **You can't live without me bonus**: **+1.5 points** for each link whose number is prime.
* **Queen of the prom bonus**: **+2 points** for a link to a question of a user with all the questions (on the site of the linked question: PPCG or SO) closed as duplicates (at least 3, including the linked one). This bonus cannot be awarded more than once per user (even if you link to all 3 questions of this user, you are awarded the bonus only once, but you can be awarded this bonus again for a link to a question of another user or the same user but on the other site).
* All bonuses are cumulative. (this for instance has the effect that the *Judge Jury Executioner bonus* will always come with the *egoistic* and *forgive me* bonuses).
* **You don't love me enough penalty**:
+ `not_enough_penalty = 0.6` for `N = 2` (just 2 links)
+ `not_enough_penalty = 0.8` for `N = 3` (just 3 links)
+ `not_enough_penalty = 1` for `N >= 4` (4 or more links)
# **Winning Criteria**:
* `LinkPoints = 1 + bonuses` for each link
* **Points** = Sum(LinkPoints) \* not\_enough\_penalty
* Votes = number of votes (upvotes - downvotes). Can be negative.
* ~~**Score** = 5 \* Points + Votes~~
* **Size** = number of bytes of original code (k = 1).
* **Score** = (256-Size) / 32 \* Points + Votes
Score is rounded to two decimals.
* **The winner** is the answer with the highest score. In the case of a tie the answer with the most votes wins.
* The winner will be awarded **two weeks** from the posting time of this question. If this question has intense activity at that time I will extend this.
# Post format
* Please specify the language, N - the number of duplication achieved, CodeSize and Points.
* Post the original piece of code.
* For each k in [1..N] post the link output-ed, the bonuses awarded and LinkPoints.
* Please add description where the way the code works is not obvious (for each k if needed) or if the language is not well-known.
* Express the formulas for Points and Score (without Votes, as they will be considered at the end of the challenge).
[Answer]
# C++, 212 bytes, 6 links, 10.31 points
```
#ifndef X
#define Y(N)s##N
#define X(N)Y(N)
#include<cstdio>
int i,j,k[]={2366,117,3818,3450,1047,2933},main;struct S{~S(){j+=k[i++];}};struct G{~G(){printf("stackoverflow.com/q/%d",j);}}g;
#endif
S X(__LINE__);
```
---
This code relies on the order of destructor to make it work (which [seems to be well defined](https://stackoverflow.com/q/469597) in this case), mainly because the preprocessor allows us to put a "prologue code" before the duplications, but not "epilogue code" because we don't know where does it end. But destructors run in reverse order, so we could put the final code (the print part) at the start as well.
The `k` array records the differences of successive link numbers. For now I just take links from the oldest pages. "6 links" seems to give the maximum score.
---
Resulting links:
1. <https://stackoverflow.com/q/2366>
2. <https://stackoverflow.com/q/2483>
3. <https://stackoverflow.com/q/6301> (is prime +1.5)
4. <https://stackoverflow.com/q/9751>
5. <https://stackoverflow.com/q/10798>
6. <https://stackoverflow.com/q/13731>
Total score: (256 - 212)/32 × 7.5 = 10.31
[Answer]
# Tcl, 155 bytes, 15 links, 55.23 points
```
[proc f args {puts stackoverflow.com/q/[lindex {2366 2483 6301 9751 10798 13731 14599 16064 16233 16550 16704 18584 20146 22708 25376} [llength $args]]}]f
```
There is a trailing space.
Links:
1. <https://stackoverflow.com/q/2366>
2. <https://stackoverflow.com/q/2483>
3. <https://stackoverflow.com/q/6301> (prime +1.5)
4. <https://stackoverflow.com/q/9751>
5. <https://stackoverflow.com/q/10798>
6. <https://stackoverflow.com/q/13731>
7. <https://stackoverflow.com/q/14599> (target **deleted**; I think it should also qualify a bonus...)
8. <https://stackoverflow.com/q/16064> (target not constructive +1)
9. <https://stackoverflow.com/q/16233>
10. <https://stackoverflow.com/q/16550>
11. <https://stackoverflow.com/q/16704>
12. <https://stackoverflow.com/q/18584>
13. <https://stackoverflow.com/q/20146>
14. <https://stackoverflow.com/q/22708>
15. <https://stackoverflow.com/q/25376>
Score = (256 - 155) / 32 \* 17.5 = 55.23
The score can probably be improved by using another set of questions with more bonuses.
[Answer]
## JavaScript (NodeJS) - 236 characters, including trailing newline
```
l=root.l||1;f=require('fs');t=(f.readFileSync(__filename)+'').split('\n');d="ge3oe gk05n gj341 gg8ah gfnar ga9i3 g602y g5mwi g2b9i fu75d g4lu0 4v1".split(' ');if(++l==t.length)console.log('https://stackoverflow.com/q/'+parseInt(d[l-2],36))
```
It uses a hardcoded list of question IDs, encoded in base 36. It reads its own source code, and only prints if it's on the last line of the file.
It results in a total of 12 questions, most closed by me:
* <https://stackoverflow.com/q/27531806> - 1 + 0.5 (forgive me) + 0.5 (dead end) = 2
* <https://stackoverflow.com/q/27807179> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/27631097> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/27603891> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/27352731> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/27153898> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/27136818> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/26981766> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/26603185> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/27088776> - 1 + 0.5 (forgive me) = 1.5
* <https://stackoverflow.com/q/6301> - 1 + 1.5 (you can't live without me) = 2.5
Link points: 18.
**Score:** 11.25
[Answer]
## STATA - 252 characters (including trailing newline) N = the number of duplicates on stackoverflow.com
Ignore the trailing space. I didn't know how to adjust this properly. Someone help me format this reasonably.
First this code tries to increment a counter variable. If that fails, it generates a new local variable and sets it equal to 2. Then it decrements it and creates a new variable to keep track of whether or not the page has the phrase " as duplicate by `<`a" in it. Until a line contains that phrase, the following is run:
Create a local variable to hold the url (using the counter as the question number). Copy the file to the local file a and replace it. Filter a (and move to b the result) by replacing ">" with ">\n" and replace b if necessary. Then read in b, clearing current data (i.e. dropping the d variable) with a string variable representing each line. If the phrase appears in any line, d becomes at least 1, thus ending the loop.
The last line displays the url and continues onto the next line because of the /// comment.
Thus, when k>1, the last line of the first part becomes
`cap di`u' ///
cap loc \`c'++`
which is equivalent to:
`cap di`u' cap loc \`c'++`
which would throw a syntax error if the capture (cap) command were not used to capture the return code and prevent execution of the line, thus not printing the url unless it is the last of the k copies of the code.
```
cap loc \`c'++
if _rc>0{
loc c=2
}
loc \`c'--
g d=0
while d<1{
loc u="http://stackoverflow.com/q/\`c'"
copy \`u' "a",replace
filef "a""b",f(>)t(>\n)r
infix str l 1-9999 using "b",clear
egen d=max(strpos(l," as duplicate by `<a"))
loc \`c'++
}
cap di\`u' ///
```
Possible better approach (explanation coming soon):
```
cap so d
if _rc>0{
loc c=9761
}
loc f="http://stackoverflow.com/"
loc u="`f'search?page=`c'&tab=newest&q=duplicate%3ayes"
infix str l 1-9999 using `u',clear
g d="`f'q/"+regexs(1) if regexm(l,f="/questions([0-9]+)")
loc `c'--
cap l d in 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/16155/edit).
Closed 2 years ago.
[Improve this question](/posts/16155/edit)
Your code just has to print "Happy 2013".
However, if it detects that it's 2014, it has to modify itself (as a running process!!) and print "Happy 2014" instead.
By self-modifying I mean the running process must really modify itself: it should alter its own instructions while it is executing.
Shortest code wins.
-10% size bonus if it's general, so it works for 2015, etc.
Sorry if the task excludes some languages or systems where it's not possible...
[Answer]
# Bash / shell script (35 chars - 10% = 31.5)
I think this shell script counts as self-modifying:
```
$ eval "y()(echo Happy `date +%Y`)";y
Happy 2013
$
```
At least, it does modify its own function `y`:
```
$ set | grep -A3 '^y ()'
y ()
{
( echo Happy 2015 )
}
$
```
---
@manatwork suggested `eval "y()(date +Happy\ %Y)";y`, which produces the desired output, but I'm not sure if this counts as self-modifying, to the extent that it self-modifies with the current year. The generated function is as follows, which won't be a different function on a yearly basis:
```
y ()
{
( date +Happy\ %Y )
}
```
If it does count, then the score is:
# Bash / shell script (29 chars - 10% = 26.1)
---
A lot of entries don't seem to make any attempt to self-modify. If we lift this restriction for shell-script, then we can do this which weighs in at:
# 15 chars - 10% = 13
```
date +Happy\ %Y
```
[Answer]
## PHP
### Creation of source code statement: 26 - 10% = 23.4
```
eval('?>Happy '.@date(Y));
```
### Overlay of existing instruction: 255 - 10% = 229.5
This can only possibly work on Linux systems configured with a writable `/proc/self/mem`, and `short_tags = On` is also assumed. (If `short_tags = Off`, replace `<?` with `<?php` , for a score of 233.1.)
```
<?$p='/proc/self/';$f=fopen($p.@mem,'r+');foreach(file($p.@maps)as$L)if(sscanf($L,'%x-%x rw%c',$i,$e,$n)>2)for(fseek($f,$i),$a=@xxxx,$e-=$i-4;$e-=4;){$b=$a;$a=fread($f,4);if($j=@strpos("x$b$a",GO.LF)){fseek($f,$j-9,1);fputs($f,@date(Y));}}$f=0?>Happy GOLF
```
Reformatted for readability:
```
<?
$p = '/proc/self/';
$f = fopen($p . @mem, 'r+');
foreach (file($p . @maps) as $L)
if (sscanf($L, '%x-%x rw%c', $i, $e, $n) > 2)
for (fseek($f, $i), $a = @xxxx, $e -= $i - 4; $e -= 4;) {
$b = $a;
$a = fread($f, 4);
if ($j = @strpos("x$b$a", GO.LF)) {
fseek($f, $j - 9, /* SEEK_CUR */ 1);
fputs($f, @date(Y));
}
}
$f = 0
?>Happy GOLF
```
[Answer]
# APL, self-modifying\*, general – 72 chars
Tested on Dyalog APL. On other systems you might have to adjust the `3+` on line 3.
```
∇H
y←2012
→(y=z←1⌷⎕TS)/k
x←⎕CR'H'⋄x[2;3+⍳4]←⍕z
⎕FX x⋄H⋄→0
k:⎕←'Happy'y
∇
```
(\*) This function does the following:
* set a variable y to some constant year;
* test whether y points to the current year; if not:
+ update its own definition, changing the numeric constant in the first line so that it sets variable y to the current year;
+ call itself recursively, so that the recursive call uses the new definition.
*Whether this is acceptable as self-modifying, I'll leave to the OP to decide.*
Example invocation, displaying the function code before and after the invocation. As you can see, line 1 has changed during the invocation:
```
∇H[⎕]∇
[0] H
[1] y←2012
[2] →(y=z←1⌷⎕TS)/k
[3] x←⎕CR'H' ⋄ x[2;3+⍳4]←⍕z
[4] ⎕FX x ⋄ H ⋄ →0
[5] k:⎕←'Happy'y
H
Happy 2013
∇H[⎕]∇
[0] H
[1] y←2013
[2] →(y=z←1⌷⎕TS)/k
[3] x←⎕CR'H' ⋄ x[2;3+⍳4]←⍕z
[4] ⎕FX x ⋄ H ⋄ →0
[5] k:⎕←'Happy'y
```
[Answer]
## Forth: 22 / 32 Chars. ( Using gforth )
```
s" Happy 2022" swap +! ( 22 chars )
```
A compiled but slightly longer version is shown here,
as the result can be decompiled, and its effects demonstrated.
Principle of operation is identical to the shorter version above.
Consider the longer version as demonstratable proof of concept.
```
: happy s" Happy 2022" swap +! ; ( 32 chars )
```
I'll decompile this first, then execute, and decompile it again:
```
see happy ( decompile happy, as it is now )
```
>
> : happy
>
> s" Happy 2022" swap +! ;
>
>
>
```
happy ( execute the self-modifying happy )
see happy ( decompile happy again )
```
>
> : happy
>
> s" Rappy 2022" swap +! ;
>
>
>
What happens here is:
s" ..." places two items on stack: address of first string character, and string length, which is 10 in this case. The sequence "swap +!" adds string length, 10, to the contents at first string address, thereby changing ASCII H to ASCII R.
A version matching the requirements slightly better is compiled using vfx:
```
: h 1 s" Happy 2021" 2dup type + 1- c+! ;
```
reason for using a different compiler for this version is that it provides c+! already which I'd have to add to gforth first, which should introduce a penalty of about 22 chars.
disassembling first:
>
> ( 080C0AF0 E81383F9FF ) CALL 08058E08 (S") "Happy 2021"
>
> ( 080C0B00 8BD3 ) MOV EDX, EBX
>
> ( 080C0B02 035D00 ) ADD EBX, [EBP]
>
> ( 080C0B05 4B ) DEC EBX
>
> ( 080C0B06 800301 ) ADD Byte Ptr 0 [EBX], 01
>
> ( 080C0B09 8BDA ) MOV EBX, EDX
>
> ( 080C0B0B FF15B9DE0408 ) CALL [0804DEB9] TYPE
>
> ( 080C0B11 C3 ) NEXT,
>
>
>
executing several times, output follows immediately:
>
> h Happy 2022
>
> h Happy 2023
>
> h Happy 2024
>
> h Happy 2025
>
> h Happy 2026
>
>
>
disassembling again:
>
> ( 080C0B30 E8D382F9FF ) CALL 08058E08 (S") "Happy 2026"
>
> ( 080C0B40 8BD3 ) MOV EDX, EBX
>
> ( 080C0B42 035D00 ) ADD EBX, [EBP]
>
> ( 080C0B45 4B ) DEC EBX
>
> ( 080C0B46 800301 ) ADD Byte Ptr 0 [EBX], 01
>
> ( 080C0B49 8BDA ) MOV EBX, EDX
>
> ( 080C0B4B FF15B9DE0408 ) CALL [0804DEB9] TYPE
>
> ( 080C0B51 C3 ) NEXT,
>
>
>
[Answer]
## Python (144 characters; 130 after removal of 10%)
This codes writes a library, thats imported (again after updating the code) and used.
```
import datetime
f=open("y.py",'w')
f.write("def year():return "+str(datetime.date.today().year))
f.close()
import y
print "Happy "+str(y.year())
```
[Answer]
# Befunge 98, 26 bytes - 10% (bonus) = 23.4
```
"EMIT"4(Yd0p" yppaH"5k,.@
```
The first space immediately after the quote gets overwritten with a unicode character with code point equal to the year.
The self-modifying part of this code actually makes it more verbose. The below code performs the same task without self-modification:
```
"EMIT"4(Y" yppaH"5k,.@
```
[Answer]
# Perl (100 characters (90 after removal of 10%))
```
$^I="";@ARGV=$0;s/ \K\d+/$l=(localtime)[5]+1900/e,print while<>;exec perl,$0if$&!=$l;print"Happy 1
"
```
It's probably too long, but I don't care (at least it's round in its size). Could be shorter if it would read UTC time (replace `localtime` with `gmtime`). Please note that after running, it will increase its size to 103 characters (unless you run this in year 10000, then 104 characters), but hey, it's self-modifying.
[Answer]
# Racket - 139 - 10% = 125.1
```
(let g((y(date-year(seconds->date(current-seconds))))(h"Happy ~a~%"))
(if(< 2013 y)(begin(set! g(lambda()(printf h y)))(g))(printf h 2013)))
```
Ungolfed:
```
(let g ((y (date-year (seconds->date (current-seconds))))
(h "Happy ~a~%"))
(if (< 2013 y)
(begin
(set! g (lambda () (printf h y)))
(g))
(printf h 2013)))
```
So I'm using a named `let` which is creating a procedure `g` and calling it with the parameter y (current year) and h (printf format string). If `y` is higher than 2013 i **redefine** `g` to a procedure that takes no arguments and prints a suitable string for the current year instead just before calling the new procedure. It's short since `h` and `y` are in the new procedures closure variables.
[Answer]
# JavaScript (ECMAScript 5)/HTML (HTML5) - 106
```
<script id=k type=x>2013</script><script>k.innerHTML=new Date().getFullYear();alert('Happy '+k.innerHTML);
```
And here is the [jsfiddle](http://jsfiddle.net/XAEQb/)
Note that in the jsfiddle, I included a closing `</script>`, but it isn't necessary, it is just necessary to work in jsfiddle
[Answer]
# Javascript 122 - 10% = 109.8
```
function n(){y=0;z=new Date().getFullYear();if(y-z){eval((""+n).replace(y,z));alert("Happy new "+z)}setTimeout(n,1000)}n()
```
It will greet you with a happy new year for the current year, and also keep checking periodically forever and greet you again if a new year comes.
[Answer]
## **Python 2,(151-10%)=136**
Inspired by [this answer](https://stackoverflow.com/questions/3057487/self-modifying-code/3057568#3057568)
```
from datetime import*
s=int(str(datetime.now())[:4]);x=2013;q=globals
def l(): return x
n="def l():return[x,s][s>x]"
exec(n,q(),q())
print'Happy %d'%l()
```
[Answer]
# PHP, 28 (-10% is 25)
```
echo"Happy ".date('Y')."!";
```
[Answer]
## HTML/JavaScript - 63 (70-10%)
```
<body onload="b.innerHTML=new Date().getFullYear()">Happy <b id=b>2013
```
] |
[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/194586/edit).
Closed 4 years ago.
[Improve this question](/posts/194586/edit)
The world has been invaded by aliens. They are everywhere killing people and taking over the world. You are hiding with your friend.
They have one weakness - the **high pitched sounds**.
You can't go yell at them, because you'd get caught before, so you remember the state had a conveniently made machine that emits a high pitched sound all over the earth, which will get rid of the aliens. The only problem is the aliens are guarding the place where the machine is and you can't possibly go there.
As your friend is an hacker, they created a program that activates the machine if you type the string `KILL ALIENS NOW!`. While they were about to type it, an alien discovered and caught 'em, throwing the **querty** keyboard on the floor. The keyboard is as show in the picture.
[](https://i.stack.imgur.com/bpsZG.png)
Somehow it still works!...well, kinda...when you type a character, the character on its right also types. So if you type 5, it will type 56. The keyboard arrows work normally and all the keys in the numpad and meta keys (print screen, etc) also work well and do nothing else.
The **delete** and **backspace** keys don't work.
Typing `shift left arrow` for example, will delete a character of code and replace it with a `z`.
Typing `j` does **not** type k, for example (this behaviour is the same for the other borbidden keys).
If you type `right shift` you will click in the `up arrow` too, for example.
The letters `k`, `i`, `l`, `a` and `n` don't work (how convenient, huh).
You decide to program the `KILL ALIENS NOW!` output, but if you do it in a lot of bytes the aliens will discover that someone is trying to break into the machine.
How will you type the string with that stupid keyboard?
# Summary of the rules
Make a program with any programming language you wish without the letters `k`, `i`, `l`, `a` and `n`, but if you type a character, it will type the one on the right too, that outputs the string `KILL ALIENS NOW!` with the least size of **bytes** possible for it to not appear in the alien's database as the current top action.
[Answer]
# [Brainfuck](https://esolangs.org/wiki/Brainfuck), ~~538~~ 221 byte
```
++++++++++[z>?+++++++>?++++++++++>?+++>?+<z<z<z<z-]\>?+++++./-=-=./+++././<z++++++++++++++++++++++++++++++++./>?-=-=-=-=-=-=-=-=-=-=-=./+++++++++++./-=-=-=./-=-=-=-=./+++++++++./+++++./<z./>?-=-=-=-=-=./+./++++++++./<z+./
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGw6iq@zsoUw4A8YGEjZVEKgbGwOV1tPXtdW11dMHM/X0baq0CQA9fTt7kBZMCDYEoQwmiEUaygRZh2ocUAKhDOwaPf3//wE "brainfuck – Try It Online")
I hope it is correct...
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), 92 bytes
```
1290/zx:"())_QWCV*(P[CVNM QRTUI*(RTRT QAS:"cv'
1290/zx#$J:"12-=!@!@j!@780-m,45hjvbvbvbvbvb<>
```
`1``9``/` (the `Shift`key that results from this can be ignored since shift by itself does nothing) `z``Right Shift``Down Arrow` (to deselect anything that may have been selected by `Shift` and its implicit `Up Arrow`)`;``9``0``q``c``8``p``c``n``Tab``r``u``8``r``r``Tab``a``;`(release `Shift`)`c``'``1``9``/``z``Right Shift``Down Arrow``3``j`(`k` is a forbidden character so is not generated)`;`(release `Shift`)`1``-``Right Shift``Down Arrow``1``1`(release `Shift`)`j``Right Shift``Down Arrow``1`(release `Shift`)`7``0``m``4``h``v``v``v``v``v``Right Shift``Down Arrow``,`
Note the literal tab characters on the first line.
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//83NLI00K@qsFLS0NSMDwx3DtPSCIh2DvPz5QwMCgn11NIICgkK4Qx0DLZSSi5T54IqV1bxslIyNNK1VXRQdMhSdDC3MNDN1TExzcgqS4JBG7v//wE "Befunge-98 (PyFunge) – 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/186546/edit).
Closed 4 years ago.
[Improve this question](/posts/186546/edit)
A magic word is a word whose Braille spelling contains precisely 26 dots (because the Morse code alphabet can be circularly encoded within). For example:
```
⠎ ⠝ ⠥ ⠛ ⠛ ⠇ ⠽ snuggly
⠏ ⠕ ⠇ ⠽ ⠛ ⠕ ⠝ polygon
⠝ ⠥ ⠛ ⠛ ⠑ ⠞ ⠽ nuggety
⠽ ⠕ ⠛ ⠓ ⠥ ⠗ ⠞ yoghurt
```
are all magic words.
**Objective:**
Craft a program to identify 77 such magic words and output the word along with its Braille spelling.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~77~~ 74 bytes
```
×6‘ḃØ⁵ịØJ⁾“»jVŒu
“¢~ỌƈY⁴⁸ġƁUP©¥!ḃ^⁶ẹøD’ḃ61
ÑOị¢BSS×LƲ⁼182µ77#Ñ€Ożị¢+⁽$ṁƊ$Ọ
```
[Try it online!](https://tio.run/##y0rNyan8///wdLNHDTMe7mg@PONR49aHu7sPz/B61LjvUcOcQ7uzwo5OKuUCMRfVPdzdc6wj8lHjlkeNO44sPNYYGnBo5aGlikCNcY8atz3ctfPwDpdHDTOBfDNDrsMT/YEmHVrkFBx8eLrPsU2PGvcYWhgd2mpurnx44qOmNf5H94DltR817lV5uLPxWJcK0Pz//wE) (Times out)
[Demo using 4 words and starting the search later in the dictionary](https://tio.run/##y0rNyan8///wdLNHDTMe7mg@PONR49aHu7sPz/B61LjvUcOcQ7uzwo5OKuUCMRfVPdzdc6wj8lHjlkeNO44sPNYYGnBo5aGlikCNcY8atz3ctfPwDpdHDTOBfDNDrsMT/YEmHVrkFBx8eLrPsU2PGvcYWhgd2mqifHjio6Y1/kf3gKW1HzXuVXm4s/FYlwrQ@P///5sZmxsbAQA)
[All 77 words produced if enough time allocated](https://tio.run/##HZFbaxNBFMff/RQuFKu0D/ahPlTFPMRLacEIXigWLdWUEvNQlCoNIjvpJaURlAZ6QVuz20sQo9DE1pnZiHBmd8j6Lf7zReKJMAxzzsz//H/nTCFfLC71es7/TOE7RO/t@pQTP52QcWDFgxx9pSMPcvmJE2fQysis83c5vjJyri8J6A8/fQldz3JyDOrbTehNqDLUGlSYniS1/PDzq9DrHrWg/BL9gAoQbaQt@/0a1EoR0an5RQd8LFyafzQXB@dzkPx06zHrIfepWYCu5v/W3zyDEv2lg8n/MAFkdcHrHt6i0DTYchBq1@7xlplmxWUnTl/cR1TNzUCtQkuzz5TebTq750TkMQK1soYhP82WOIA8MjvQtaQG@SXDvGw9f8Mcc7m4Sscz3J3dM2vmI1RzzFayRnIValzoHrJXt2GbUAdxEG/P2cpDdlLLib94kRhxdRxyJe1QO61TwLPiguzJQXtyGLIM/cEJDdlmhszr0fRk5I6tDNkd7u1p0nm1lPimwtyu3IQM022oOvNdn10oDb4dT6J@QvRbiXhmyebi3aTDHVM45MTvAb6yGwP8pROsnur1/gE)
A full program that generates 77 seven-letter words from Jelly’s dictionary that require exactly 26 dots in Braille. Now outputs a list of lists with the word in ASCII and then Braille.
] |
[Question]
[
**This question already has answers here**:
[Is this Sequence Graphic?](/questions/108804/is-this-sequence-graphic)
(12 answers)
Closed 4 years ago.
It was a dark and stormy night. Detective Havel and Detective Hakimi arrived at the scene of the crime.
Other than the detectives, there were 10 people present. They asked the first person, "out of the 9 other people here, how many had you already met before tonight?" The person answered "5". They asked the same question of the second person, who answered "3". And so on. The 10 answers they got from the 10 people were:
```
5 3 0 2 6 2 0 7 2 5
```
The detectives looked at the answers carefully and deduced that there was an inconsistency, and that somebody must be lying. (For the purpose of this challenge, assume that nobody makes mistakes or forgets, and if X has met Y, that means Y has also met X.)
Your challenge for today is, given a sequence of answers to the question "how many of the others had you met before tonight?", apply the Havel-Hakimi algorithm to determine whether or not it's possible that everyone was telling the truth.
If you're feeling up to it, skip ahead to the Challenge section below. Otherwise, try as many of the optional warmup questions as you want first, before attempting the full challenge.
**Optional Warmup 1: eliminating 0's.**
Given a sequence of answers, return the same set of answers with all the 0's removed.
```
warmup1([5, 3, 0, 2, 6, 2, 0, 7, 2, 5]) => [5, 3, 2, 6, 2, 7, 2, 5]
warmup1([4, 0, 0, 1, 3]) => [4, 1, 3]
warmup1([1, 2, 3]) => [1, 2, 3]
warmup1([0, 0, 0]) => []
warmup1([]) => []
```
If you want to reorder the sequence as you do this, that's fine. For instance, given `[4, 0, 0, 1, 3]`, then you may return `[4, 1, 3]` or `[1, 3, 4]` or [`4, 3, 1]` or any other ordering of these numbers.
**Optional Warmup 2: descending sort**
Given a sequence of answers, return the sequence sorted in descending order, so that the first number is the largest and the last number is the smallest.
```
warmup2([5, 1, 3, 4, 2]) => [5, 4, 3, 2, 1]
warmup2([0, 0, 0, 4, 0]) => [4, 0, 0, 0, 0]
warmup2([1]) => [1]
warmup2([]) => []
```
**Optional Warmup 3: length check**
Given a number `N` and a sequence of answers, return true if `N` is greater than the number of answers (i.e. the length of the sequence), and false if `N` is less than or equal to the number of answers. For instance, given `7` and `[6, 5, 5, 3, 2, 2, 2]`, you would return `false`, because 7 is less than or equal to 7.
```
warmup3(7, [6, 5, 5, 3, 2, 2, 2]) => false
warmup3(5, [5, 5, 5, 5, 5]) => false
warmup3(5, [5, 5, 5, 5]) => true
warmup3(3, [1, 1]) => true
warmup3(1, []) => true
warmup3(0, []) => false
```
**Optional Warmup 4: front elimination**
Given a number `N` and a sequence in descending order, subtract 1 from each of the first `N` answers in the sequence, and return the result. For instance, given `N = 4` and the sequence `[5, 4, 3, 2, 1]`, you would subtract 1 from each of the first 4 answers (5, 4, 3, and 2) to get 4, 3, 2, and 1. The rest of the sequence (1) would not be affected:
```
warmup4(4, [5, 4, 3, 2, 1]) => [4, 3, 2, 1, 1]
warmup4(11, [14, 13, 13, 13, 12, 10, 8, 8, 7, 7, 6, 6, 4, 4, 2]) => [13, 12, 12, 12, 11, 9, 7, 7, 6, 6, 5, 6, 4, 4, 2]
warmup4(1, [10, 10, 10]) => [9, 10, 10]
warmup4(3, [10, 10, 10]) => [9, 9, 9]
warmup4(1, [1]) => [0]
```
You may assume that `N` is greater than 0, and no greater than the length of the sequence. Like in warmup 1, it's okay if you want to reorder the answers in your result.
Challenge: the Havel-Hakimi algorithm
Perform the Havel-Hakimi algorithm on a given sequence of answers. This algorithm will return true if the answers are consistent (i.e. it's possible that everyone is telling the truth) and false if the answers are inconsistent (i.e. someone must be lying):
Remove all 0's from the sequence (i.e. warmup1).
If the sequence is now empty (no elements left), stop and return true.
Sort the sequence in descending order (i.e. warmup2).
Remove the first answer (which is also the largest answer, or tied for the largest) from the sequence and call it N. The sequence is now 1 shorter than it was after the previous step.
If `N` is greater than the length of this new sequence (i.e. warmup3), stop and return false.
Subtract 1 from each of the first `N` elements of the new sequence (i.e. warmup4).
Continue from step 1 using the sequence from the previous step.
Eventually you'll either return true in step 2, or false in step 5.
You don't have to follow these steps exactly: as long as you return the right answer, that's fine. Also, if you answered the warmup questions, you may use your warmup solutions to build your challenge solution, but you don't have to.
```
hh([5, 3, 0, 2, 6, 2, 0, 7, 2, 5]) => false
hh([4, 2, 0, 1, 5, 0]) => false
hh([3, 1, 2, 3, 1, 0]) => true
hh([16, 9, 9, 15, 9, 7, 9, 11, 17, 11, 4, 9, 12, 14, 14, 12, 17, 0, 3, 16]) => true
hh([14, 10, 17, 13, 4, 8, 6, 7, 13, 13, 17, 18, 8, 17, 2, 14, 6, 4, 7, 12]) => true
hh([15, 18, 6, 13, 12, 4, 4, 14, 1, 6, 18, 2, 6, 16, 0, 9, 10, 7, 12, 3]) => false
hh([6, 0, 10, 10, 10, 5, 8, 3, 0, 14, 16, 2, 13, 1, 2, 13, 6, 15, 5, 1]) => false
hh([2, 2, 0]) => false
hh([3, 2, 1]) => false
hh([1, 1]) => true
hh([1]) => false
hh([]) => true
```
Detailed example
Here's the first pass through the algorithm using the original example:
`[5, 3, 0, 2, 6, 2, 0, 7, 2, 5]` - Starting sequence
`[5, 3, 2, 6, 2, 7, 2, 5]` - After step 1, removing 0's.
Step 2: This sequence is not empty, so go on to step 3.
`[7, 6, 5, 5, 3, 2, 2, 2]` - After step 3, sorting in descending order.
`[6, 5, 5, 3, 2, 2, 2]` - After step 4, removing the first answer `N = 7`.
Step 5: N (7) is less than or equal to the number of answers remaining in the sequence (7), so go on to step 6.
`[5, 4, 4, 2, 1, 1, 1]` - After step 6, subtracting 1 from each of the first 7 answers (which is all of them in this case).
At this point you would start over at step 1 with the sequence `[5, 4, 4, 2, 1, 1, 1]`. After your second pass through the algorithm, your sequence will be `[3, 3, 1, 0, 0, 1]`, so start back at step 1 with this sequence. After your third pass you'll have `[2, 0, 0]`. On your fourth pass, you'll stop at step 5, because you'll have `N = 2` and an empty sequence (`[]`), and 2 > 0, so you will return false.
~
***Thought this would be fun to golf***
* Shortest code wins.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~23~~ 12 [bytes](https://github.com/DennisMitchell/jelly)
```
ṢṚḢ-€+ƊƊƬ>-Ȧ
```
A monadic Link accepting a list which yields `1` if the answers are consistent otherwise `0`.
**[Try it online!](https://tio.run/##y0rNyan8///hzkUPd856uGOR7qOmNdrHuoBwjZ3uiWX///@PNjTRUTA0AGJzIDbWUQByLXQUzHQUoHwwBrEtwBIgphGQMgGrMYEoM4oFAA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##TVC7DcIwEO0zhXscyefETmhYgAlQlJIGZQFaGiRKKkSZgioDEIkOBbGGWcTcx0EoPt/5nd/z5e22XbePMYx9GK/h3uefw7B4nfAbVvn7FqdzGC@ITY/nEdMaYxNj0zitCq2MVlYrzzvWFReuzXRTzhgggAVhBZ8sMyFhgOQlL3CcKjlgHyrJpSDIgzKFla4RKc9ChJvEKphV82jpzEF1zQ2QWYnl@TK1LAs5ueQTx3J7flnwev5vGt/IfCZp4EwkIw34C8cPi2usJb7BzxaqvBhBM5CKFRuTezahMGfa2qz9Ag "Jelly – Try It Online").
### How?
```
ṢṚḢ-€+ƊƊƬ>-Ȧ - Link: list of integers
Ƭ - collect up while results change:
Ɗ - last three links as a monad i.e. f(L):
Ṣ - sort [min(L),...,max(L)]
Ṛ - reverse [max(L),...,min(L)]
Ɗ - last three links as a monad i.e. f([a,b,c,...,x]):
Ḣ - pop head a
-€ - -1 for each [-1,-1,...,-1] (length a)
+ - add (vectorises) [b-1,c-1,...,x-1,-1,-1,...]
>- - greater than -1? (vectorises)
Ȧ - Any and all? (0 if empty or contains a 0 when flattened, else 1)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 90 bytes
Forgoes zero-pruning in favor of saving 2 bytes. Who needs that, anyways? Instead, I count how many I've decremented (skipping over zeroes) and if I haven't decremented the current largest number fully, then it's a false.
I really hoped that I could forgo sorting as well but alas, things don't always work as planned...
```
->a{b=1;(a.sort_by!(&:-@);i=a.shift;a.map!{|e|i>0&&e>0?(i-=1;e-1):e};b&&=i<1)while[]!=a;b}
```
[Try it online!](https://tio.run/##bVHbaoQwEH3vV5gXMaCSideu1fY/tlJiUTZg6bIXyrK7326TGS1LLDhmMufMYebkcO4u01C/T1Gjrl0NVaDi4/fh9NFdWOBvojde6dqUdno4VSr@Unt2vfU33Qjf7xvxGujINPUR8E1/rzrfr/UL8J@dHvtty2pVdfdp7zE2xJ9qHINtFnpJ6InQk6GX49/kBSZZy58eqekCg8FM4sAJAhL1YA2DUX/GDzI8CroYKhR0plQxEpDOIQkVpJq7mpYiZoEEBUpcY75j2LxEAGgv25Uj2ULS1cyIn8/tEpnLPFQvF7vsUoKmFrOcmdRRJA48RIbjkO8oS87Dn4U2y8kpO44jKOkh1v7LNRf@KTn3lk@/ "Ruby – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 22 bytes
```
ḟ0ṢṚ0_1x$}ß`ɗL<¥?Ḣ$1L?
```
[Try it online!](https://tio.run/##y0rNyan8///hjvkGD3cuerhzlkG8YYVK7eH5CSen@9gcWmr/cMciFUMf@//e1o8a5ijo2ik8aphrfbid63D7o6Y1kf//R3NFm@ooGOsoGOgoGOkomIFJINsczDCN1eGKNtRRMATRyOqACCzMFQsA "Jelly – Try It Online")
A full program that takes the input list of answers as its argument and returns 1 for valid and 0 for impossible.
Thanks to @JonathanAllan for noting an issue with the second version.
] |
[Question]
[
Inspired (you don't need to know them for this challenge) by the [Pumping Lemma](https://en.wikipedia.org/wiki/Pumping_lemma) for [various](https://en.wikipedia.org/wiki/Pumping_lemma_for_regular_languages) [languages](https://en.wikipedia.org/wiki/Pumping_lemma_for_context-free_languages), I propose the following challenge:
* choose some basis \$B \geq 2\$ and an integer \$n \geq 0\$
* write a program/function \$P\$
* partition\* \$P\$ into some strings \$s\_i \neq \epsilon\$, st. \$P = s\_n | \cdots | s\_i | \cdots | s\_0\$
So far easy enough, here comes the tricky part: The program \$P\$ must for any given string with \$e\_i \in \mathbb{N}^+\$
$$(s\_n)^{e\_n} | \cdots | (s\_i)^{e\_i} | \cdots | (s\_0)^{e\_0}$$
output \$\sum\_{i=0}^n e\_i \cdot B^i\$ and something distinct from any positive number (eg. erroring, \$0\$, \$-1\$ etc.) for any other string.
\* You must ensure that for a pumped string as described above the \$e\_i\$s are unique.
### Informal Explanation
Write a program and split it into a fixed number of chunks and pick a power-series (eg. \$1,2,4,8,\dotsc\$). The program needs to take a string as input and output a number in the following way:
1. First decide if the input string is made out of the same chunks (in order) as the program, though each chunk can be repeated any number of times. If this is not the case, return \$0\$, a negative number, error out etc.
2. Count the number of times each chunk is repeated and output (using the powerseries of \$2\$ as example): `number_of_last_chunk * 1 + number_of_second_last_chunk * 2 + number_of_third_last_chunk * 4 + ...`
Thanks [Laikoni](https://codegolf.stackexchange.com/users/56433/laikoni) for helping me with the explanation!
## Example
Suppose I have the program \$\texttt{ABCDEF}\$ and I choose \$n = 2\$ with the partitioning \$s\_2 = \texttt{ABC}\$, \$s\_1 = \texttt{D}\$ and \$s\_0 = \texttt{EF}\$, choosing basis \$B = 2\$ we would have the following example outputs (the input is given to the original program):
$$
\begin{aligned}
\text{Input} &\mapsto \text{Output} \\\
\texttt{ABCDE} &\mapsto 0 \\\
\texttt{ABCDEF} &\mapsto 7 \\\
\texttt{ABCDEFEF} &\mapsto 8 \\\
\texttt{ABCABCDEF} &\mapsto 11 \\\
\texttt{ABCDDEFEFEF} &\mapsto 11 \\\
\texttt{ABCABCDDEF} &\mapsto 13
\end{aligned}
$$
This submission has score \$3\$.
## Walk-through
The example \$\texttt{ABCDE}\$ maps to \$0\$ because the \$\texttt{F}\$ is missing.
---
Now let's walk through the fifth example: The input is \$\texttt{ABCDDEFEFEF}\$ which we can write using the strings \$s\_2,s\_1,s\_0\$ as follows:
$$
(\texttt{ABC})^1 | (\texttt{D})^2 | (\texttt{EF})^3
$$
So this gives us \$1\cdot 2^2 + 2 \cdot 2^1 + 3 \cdot 2^0 = 4+4+3 = 11\$.
# Winning criterion
The score of your program/function will be \$n+1\$ where larger is better, ties will be the submission date earlier is better.
In case you're able to generalize your submission to an arbitrarily large \$n\$, you may explain how and score it as \$\infty\$.
---
**Notations:** \$\epsilon\$ denotes the empty string, \$x | y\$ the string concatenation of \$x\$ and \$y\$ & \$x^n\$ is the string \$x\$ repeated \$n\$ times.
[Answer]
# Mathematica, \$B=2\$, score \$\infty\$
```
With[{s =
StringJoin[StringRepeat["a", #] <> "b" & /@ Reverse[Range[#]]]},
ToString[(s;
StringReplace[#,
StartOfString ~~ a : "(\"" .. ~~ b : ("a" .. ~~ "b") .. ~~
c : ("\"; " <>
StringTake[
ToString[Extract[#0, {1, 2}, Hold],
InputForm], {6, -2}] <> ") & ") .. ~~ EndOfString /;
AllTrue[Differences[
d = Length /@ Split[Characters[b]][[;; ;; 2]]], -2 < # <
1 &] && Length[d] > 1 :>
2^Max[d] StringLength[a] + Total[2^# #2 & @@@ Tally[d]] +
StringLength[c]/389][[1]]) &, InputForm]] &
```
Pure function. Takes \$k=n-1\$ as input and returns the string representing \$P\_k\$ as output (for \$k\geq2\$). For the purposes of illustration, take this formatted version of \$P\_3\$:
```
("aaabaabab";
StringReplace[#1,
StartOfString ~~ a : ("(\"" ..) ~~ b : (("a" .. ~~ "b") ..) ~~
c : ("\"; " <>
StringTake[
ToString[Extract[#0, {1, 2}, Hold], InputForm], {6, -2}] <>
") & " ..) ~~ EndOfString /;
AllTrue[Differences[
d = Length /@
Split[Characters[b]][[1 ;; All ;; 2]]], -2 < #1 < 1 &] &&
Length[d] > 1 :>
2^Max[d] StringLength[a] +
Total[Apply[2^#1 #2 &, Tally[d], {1}]] + StringLength[c]/389][[
1]]) &
```
This function takes a string as input and either returns a positive integer or an invalid expression (`"..."[[1]]`) as output. Here, \$s\_4=\texttt{("}\$, \$s\_3=\texttt{aaab}\$, \$s\_2=\texttt{aab}\$, \$s\_1=\texttt{ab}\$, and \$s\_0\$ encompasses the remainder of the function.
] |
[Question]
[
Write a program to generate a rectangular word-search of size 6x9. Words may go downwards, rightwards and diagonally (downwards and to the right), they may also overlap on the board.
The challenge is to include as many different English words as possible from <https://www.ef.co.uk/english-resources/english-vocabulary/top-3000-words> Your program may select desirable words itself to include. You score 1 point per word included.
---
For example:
For clarity I've used "." symbols below instead of random letters.
```
dolphin..
o.....o..
g.....u..
.....ono.
.........
.........
```
The above word-search contains {'do', 'dog', 'dolphin', 'hi', 'i', 'in', 'no', 'noun', 'on', and 'phi'} so from what is filled in so far scores 10 points.
In the unlikely event of a tie the shortest code size will be used to choose a winner.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 bytes, score ~~53~~ 57
```
“¦/œḌ⁼ƥ~ẹµḲ5&Ċd@ṡ»ḲY
```
**[Try it online!](https://tio.run/##ATEAzv9qZWxsef//4oCcwqHigbzJvG0h4biLVsK/wr/igb3GkSThuZkpOeG5qsK74biyWf// "Jelly – Try It Online")**
Wordsearch:
```
a d m i s s i o n
h o u s e h o l d
s o m e t h i n g
g e n e r a l l y
p o t e n t i a l
t h e r e f o r e
```
Words:
```
admission generally household potential something therefore
general mission
house stair there thing
ally gene here hill hold miss some tent thin
air all due era for hat her ill oil old one pot see set son ten the use
ad ah at do go he hi ie in me ms oh on or so to us
i
```
---
**Previous**
...the dictionary referenced in the question has changed since this was posted so this would drop to a score of 33.
# [Jelly](https://github.com/DennisMitchell/jelly), 23 bytes, score ~~150 154 158~~ 160
```
“RʂȥḄ0ḣq⁾÷yḊzIḥẊḥYx »ḲY
```
**[Try it online!](https://tio.run/##ATYAyf9qZWxsef//4oCcUsqCyKXhuIQw4bijceKBvsO3eeG4inpJ4bil4bqK4bilWXggwrvhuLJZ//8 "Jelly – Try It Online")**
Used Python to search for boards; there are, no doubt, higher scores possible though.
The board:
```
donations
beverages
placement
performed
metallica
thousands
```
The words:
```
['a', 'ac', 'ace', 'ae', 'ag', 'age', 'ages', 'al', 'all', 'am', 'an', 'and', 'ar', 'art', 'as', 'at', 'ati', 'au', 'b', 'be', 'beverage', 'beverages', 'bp', 'c', 'ca', 'cd', 'ce', 'cement', 'cf', 'd', 'da', 'das', 'db', 'do', 'don', 'donation', 'donations', 'ds', 'e', 'ec', 'ed', 'ee', 'eh', 'el', 'em', 'en', 'ent', 'er', 'era', 'es', 'et', 'ev', 'eve', 'ever', 'f', 'fa', 'fo', 'for', 'form', 'formed', 'g', 'ge', 'gem', 'h', 'ho', 'i', 'ia', 'ic', 'in', 'io', 'ion', 'l', 'la', 'lace', 'le', 'lee', 'li', 'll', 'ls', 'm', 'me', 'med', 'men', 'ment', 'met', 'meta', 'metal', 'metallic', 'metallica', 'mi', 'min', 'mr', 'mt', 'n', 'na','nat', 'nation', 'nations', 'nd', 'ne', 'nec', 'ns', 'nt', 'nv', 'o', 'oe', 'og', 'ol', 'on', 'ons', 'or', 'ou', 'p', 'pe', 'per', 'perform', 'performed', 'pl', 'place', 'placement', 'pm', 'pp', 'ppm', 'r', 'ra', 'rage', 're', 'rf', 'rl', 'rm', 'rt', 's', 'sa', 'san', 'sand', 'ss', 'st', 'std', 't', 'ta', 'tall', 'td', 'th', 'thou', 'thousand', 'thousands', 'ti', 'tion', 'tions', 'to', 'tr', 'treo', 'u', 'us', 'usa', 'v', 'va', 'var', 've', 'ver']
```
---
[Answer]
# [Lua](https://www.lua.org), 73 bytes - 49 66 74 75 words
```
print("abraiders\nscrapings\nsheathers\ncarabiner\nbrahmanis\nrelapsers")
```
[Try it online!](https://tio.run/##HctBDoAgDAXRu7DSO7H5YiNNoDQtnr8iu8lLpr2IUGOZR8Jl4JvMsxg1qO/0YlCW589KmHVrGV1pLs6yrtoh7OmM@AA "Lua – Try It Online")
I got the words from another StackExchange question on the [Puzzles](https://puzzling.stackexchange.com/questions/9890/the-most-words-that-can-be-made-by-successively-adding-one-letter-to-the-origina) site. Prints:
```
abraiders
scrapings
sheathers
carabiner
brahmanis
relapsers
```
So it's a minimum of eight words each row for 48 words, plus the indefinite article 'a' for 49 words horizontally. **Edit**: It seems there was an edit to the challenge and there now may be a limit to a list of very specific words and, unlike all of the words forming my list, not all of those words are actually even English. *sigh* Might just leave this here for posterity.
**Edit**
Words formed horizontally:
```
i (pronoun 'I')
id
aid
aide
raid
aider
braid
aiders
raider
raiders
braiders
abraiders
la
lap
laps
lapse
elapse
relapse
relapser
relapsers
in
pin
rap
ping
crap
pings
aping
scrap
raping
craping
scraping
scrapings
at
he
eat
her
she
the
eath
heat
hers
heath
sheath
sheathe
sheather
sheathers
a
ab
rab
bin
car
arab
arabi
arabin
arabine
carabine
carabiner
is
ra
rah
man
bra
rahm
brahm
brahma
brahman
brahmani
brahmanis
```
Words formed vertically:
```
as
aha
are
ass
era
char
hare
```
] |
[Question]
[
**Idea:**
Consider a 2-bit bitmap of arbitrary side-lengths overlaid on a coordinate grid and imaged with random data (1's represent an element of the image, 0's represent the "blank" canvas background):
```
y x—0 2 4 6 8 10 14 18
|
0 0000000000111100000000
0000000011111110000000
2 0000111111111111000000
0000011111111111000000
4 0000000000000000000000
1111111000000000011111
6 1111111111100000000011
1111111111111111000000
```
Next, consider how the rasterized image may be described using a series of drawn, solid rectangles. Example:
```
0 2 4 6 8 101214161820
0 0000000000111100000000
0000000011111110000000
2 0000111111111111000000
0000011111111111000000
4 0000000000000000000000
xxxxxxx000000000011111
6 xxxxxxx111100000000011
xxxxxxx111111111000000
```
The x's describe a region of the bitmap that may be described using a solid rectangle. Finally, consider how that rectangular section of the image can be described under the X-Y coordinate system by two of its vertices in the format:
```
{x0,y0,x1,y1}
```
In this case,
```
{0,5,6,7}
```
describes the example rectangular section.
**Challenge:**
Design a program which receives a 2D matrix containing bitmap data and outputs a concatenated list of rectangle coordinates.
**Restrictions:**
The output, when processed by remapping (plotting using 1's) the rectangles back onto a blank coordinate canvas (a canvas of all 0's) of the same side-length dimensions, should yield exactly the input matrix.
The output should be a concatenated list of all computed rectangles, no extraneous parsing characters or structures distinguishing one set of coordinates from another. The list will be read top-down, ordering will be inferred given that each rectangle requires only two coordinates to be described.
**Example I/O:**
(Do mind that this example in no way presents the ideal output, however, it is a valid output.)
Input 2D matrix:
```
0000000000111100000000
0000000011111110000000
0000111111111111000000
0000011111111111000000
0000000000000000000000
1111111000000000011111
1111111111100000000011
1111111111111111000000
```
Output concatenated list:
```
{10,0,13,3,8,1,9,3,5,2,7,3,4,2,4,2,14,1,14,3,15,2,15,3,0,5,6,7,7,6,10,7,11,7,15,7,17,5,21,5,20,6,21,6}
```
**Efficiency score:**
Programs will be ranked by their average-case efficiency using [this](https://tio.run/##TYxBCoMwEEXXmVN8XOlCiF10U3qY1kxoQMcyppCcPkZR6PK//3hz7t@vNYylOPbwrXRkgoc8LeKHBcrxpwILnla@1kAsrvrkF0Xe1QU32w9kdpD@gflqkFjDKq69d7UunCISnUfTPOgguZQN) resource (or one which functions identically) to generate pseudorandom, 2-bit, 20x20 matrices. Determine the average-case efficiency by calculating the arithmetic mean of the output lengths of at least 10 iterations (sum of the lengths divided by the number of iterations). The lesser the average length of the output, the greater the efficiency.
[Answer]
# Rust
[Try it online](https://play.rust-lang.org/?gist=de70b1786971d75ac086413736fc66ff)
Average case num rectangles: **57.9054** (10000 iterations of 20x20 matrices, with 1/7 probability of "0")
Solution to example input:
`{10,0,13,3,8,1,14,3,4,2,15,2,5,3,15,3,0,5,6,7,17,5,21,5,0,6,10,7,20,6,21,6,0,7,15,7}`
The algorithm is pretty simple: for each horizontal line of 1s, use that as the top side of a rectangle, extend this rectangle down while possible, and if it covers some previously uncovered area, add it to the list. This assumes rectangles can overlap. I have not verified whether the output is always correct, but the example input looks ok. The output was verified against the input for 10000 iterations, and it looks correct.
The code includes a benchmark function to calculate the score, and a function to draw the result. The input can be changed in the main function.
```
extern crate rand;
use rand::{Rng, thread_rng};
#[derive(Copy, Clone, Debug)]
struct Rect {
x0: usize,
y0: usize,
x1: usize,
y1: usize
}
impl Rect {
fn contains_xslice(&self, xa: usize, xb: usize) -> bool {
self.x0 <= xa && xb <= self.x1
}
fn contains(&self, r: &Rect) -> bool {
// r is completely inside of self
self.x0 <= r.x0 && r.x1 <= self.x1 && self.y0 <= r.y0 && r.y1 <= self.y1
}
}
fn display_rects(r: &[Rect]) -> String {
let s = r.iter()
.map(|z| format!("{},{},{},{}", z.x0, z.y0, z.x1, z.y1))
.collect::<Vec<_>>()
.join(",");
// transform 1,1 into {1,1}
format!("{{{}}}", s)
}
fn draw_rects(r: &[Rect], w: usize, h: usize) -> String {
let mut s = format!("");
for y in 0..h {
for x in 0..w {
let p = Rect { x0: x, x1: x, y0: y, y1: y };
if r.iter().any(|a| a.contains(&p)) {
s.push_str("1");
} else {
s.push_str("0");
}
}
s.push_str("\n");
}
s
}
#[derive(Clone, Debug, PartialEq, Eq)]
struct Matrix {
v: Vec<u8>,
size: (usize, usize),
}
impl Matrix {
fn new(w: usize, h: usize) -> Self {
Self {
v: vec![0; w*h],
size: (w, h),
}
}
fn from_str(s: &str) -> Self {
let mut v = vec![];
let mut w = None;
let mut h = 0;
for l in s.lines() {
h += 1;
let mut tw = 0;
for c in l.chars() {
tw += 1;
let x = match c {
'0' => 0,
'1' => 1,
a => panic!("Invalid input! {:?} at {},{}", a, tw, h),
};
v.push(x);
}
if let Some(ww) = w {
if tw != ww {
panic!("All lines must have the same width! {} != {}", tw, ww);
}
} else {
w = Some(tw);
}
}
let w = w.unwrap_or(0);
Matrix {
v,
size: (w, h),
}
}
fn random(w: usize, h: usize) -> Self {
let mut rng = thread_rng();
let mut v = vec![];
for _ in 0..w*h {
let n = rng.gen_range(0, 6+1);
let x = if n == 0 { 0 } else { 1 };
v.push(x);
}
Matrix {
v,
size: (w, h),
}
}
fn get(&self, x: usize, y: usize) -> u8 {
self.v[y * self.size.0 + x]
}
fn hline(&self, y: usize) -> &[u8] {
&self.v[y * self.size.0 .. (y + 1) * self.size.0]
}
fn hline_1_pieces(&self, y: usize) -> Vec<Rect> {
let mut r = vec![];
let line = self.hline(y);
let xmax = self.size.0 - 1;
let y0 = y;
let y1 = y;
let mut lineit = line.iter();
let mut xoff = 0;
while lineit.len() > 0 {
// Find first non-zero pixel
if let Some(x0) = lineit.position(|&x| x != 0) {
let x0 = xoff + x0;
// x0..x1 is a line of 11111
let x1 = x0 + lineit.position(|&x| x == 0).unwrap_or(xmax - x0);
r.push(Rect { x0, x1, y0, y1 });
// Remember offset because the iterator is being consumed
xoff = x1 + 2;
}
}
r
}
fn rectangles(&self) -> Vec<Rect> {
let mut r: Vec<Rect> = vec![];
let ymax = self.size.1 - 1;
// For each hline, add rectangles covering the maximum width possible
let hpieces: Vec<Vec<Rect>> = (0..self.size.1).map(|i| self.hline_1_pieces(i)).collect();
// Extend each rectangle down while possible
for (y0, layer) in hpieces.iter().enumerate() {
for rect in layer {
let mut y = y0 + 1;
while y <= ymax {
if hpieces[y].iter().any(|&r| r.contains_xslice(rect.x0, rect.x1)) {
y += 1;
} else {
break;
}
}
let y1 = y - 1;
let rn = Rect { y1, ..*rect };
if r.iter().any(|&r1| r1.contains(&rn)) {
// An equivalent rectangle is already in the vec
} else {
// This rectangle covers some new area, push it
r.push(rn);
}
}
}
r
}
}
fn benchmark(iterations: usize) -> f64 {
let mut sum = 0;
for _ in 0..iterations {
let m = Matrix::random(20, 20);
let r = m.rectangles();
let output = draw_rects(&m.rectangles(), 20, 20);
assert_eq!(m, Matrix::from_str(&output));
sum += r.len();
}
sum as f64 / iterations as f64
}
fn main() {
let input = "\
0000000000111100000000
0000000011111110000000
0000111111111111000000
0000011111111111000000
0000000000000000000000
1111111000000000011111
1111111111100000000011
1111111111111111000000
";
let m = Matrix::from_str(input);
assert_eq!(input, draw_rects(&m.rectangles(), 22, 8));
println!("{}", display_rects(&m.rectangles()));
println!("{}", benchmark(10000));
}
```
[Answer]
# Python 3 + [Z3](https://github.com/Z3Prover/z3), optimal, 51.19 ± 0.10 rectangles
(Random 20×20 bitmaps with \$\frac17\$ probability of 0, average of 10000 cases, 95% confidence interval.)
```
import sys
import z3
bitmap = [list(map(int, line)) for line in sys.stdin.read().splitlines()]
height = len(bitmap)
width = len(bitmap[0])
rects = set()
for y0 in reversed(range(height)):
for x0 in reversed(range(width)):
x2 = width - 1
for y1 in range(y0, height):
if bitmap[y1][x0] != 1:
break
x1 = x0
while x1 < x2 and bitmap[y1][x1 + 1] == 1:
x1 += 1
rects.discard((x0 + 1, y0, x1, y1))
rects.discard((x0, y0 + 1, x1, y1))
rects.discard((x0, y0, x1, y1 - 1))
rects.add((x0, y0, x1, y1))
x2 = x1
cover = {
(x, y): [] for y in range(height) for x in range(width) if bitmap[y][x] == 1
}
use = {}
for x0, y0, x1, y1 in rects:
u = use[x0, y0, x1, y1] = z3.Bool(f"use{x0}_{y0}_{x1}_{y1}")
for y in range(y0, y1 + 1):
for x in range(x0, x1 + 1):
cover[x, y].append(u)
solver = z3.Optimize()
solver.add([z3.Or(c) for c in cover.values()])
solver.minimize(z3.Sum([z3.If(u, 1, 0) for u in use.values()]))
assert solver.check() != z3.unsat
model = solver.model()
print(sum((list(rect) for rect, u in use.items() if z3.is_true(model[u])), []))
```
] |
[Question]
[
(language-specific challenge)
## Specification:
Language: ECMAScript, any version[1]
Challenge: Somewhat like python's [itertools.groupBy](https://docs.python.org/2/library/itertools.html#itertools.groupby): Your function `Array.group(f)` should take as input an "equivalence function" `f` whose output defines our notion of an "equivalence key" for array elements (like a sort key). The return value of `.group(f)` should be an array of arrays in the same order, split whenever the value of the keyfunc parameter changes (in the `===` sense).
```
Object.defineProperties(Array.prototype, {
group: {
value: function(f) {/*
CODE GOES HERE
*/}
}
});
```
## Examples / test cases:
```
> ['a','c','E','G','n'].group(x => x==x.toUpperCase())
[['a','c'], ['E','G'], ['n']]
> [1,1,'1'].group(x=>x)
[[1,1],['1']]
> [3,1,'1',10,5,5].group(x=>x+2)
[[3], [1], ['1'], [10], [5,5]]
> [{a:1,b:2,c:3}, {b:2,a:1,c:0}, {c:5}].group(x => JSON.stringify([x.a, x.b]))
[[{a:1,b:2,c:3},{b:2,a:1,c:0}], [{c:5}]]
> [].group(x=>x)
[]
```
## Scoring criteria:
score = # of characters that replace comment above (lower is better), with easements that:
1. whitespace and statement-separating semicolons don't count towards total[2]
2. variable names and keywords each count as exactly 1 characters towards total per use[3]; this includes builtins, so `Array.map.apply` would be 5 'characters' (however, builtins count their full length as tiebreakers)
3. -5 bonus points if `f` being undefined has same result as the identity function `x=>x`
4. you may modify the construct `function(f) {...}` for recursion/combinator purposes while keeping it as a `function` respecting rule #5, but must subtract from your score the extra characters incurred (i.e. imagine the scoring began earlier)
## Disallowances:
5. no side-effects which affect anything other than your code (such as modifying `this`, `window`, the prototype, etc.); as a corollary, all definitions must stay local to the `.group` function (e.g. `x=5` would be disallowed, but `var x=5` is fine)
minor notes:
[1] draft specs fine if in any major browser, proprietary extensions fine if in 2+ major browsers;
[2] as long as you don't try to compile a few megabytes-long whitespace ;-)
[3] as long as reflection is not used to abuse code-in-variable-names ;-)
---
## Errata:
Answer may do anything reasonable with regards to sparse arrays. e.g. `arr=[1,1]; arr[4]=1; arr` -> `[1, 1, empty × 2, 1]`. Possibilities include ignoring them (like `.map` and friends do), or treating them as `undefined` (like an incremental for-loop would), or anything reasonable. For example `arr.group(x=>x)` might return `[[1,1],[undefined,undefined],[1]]`, or `[[1,1,1]]`, or even more dubious things like `[[1,1],null,[1]]` if it makes sense. You may also assume sparse arrays do not exist.
edit: #2 now applies to keywords.
You may find the following snippet useful to estimate score (the rules supercede this snippet though):
```
var code = `......`;
console.log('score estimate:', code.replace(/\w+/g,'X').replace(/[\s;]/g,'').replace(/X(?=X)/g,'X ').length, '-5?');
```
[Answer]
# JavaScript, 47 points (53 tiebreaker)
```
Array.prototype.group = function(f){
const r = []
let k = r
for(const i of this)
k !== (k = f ? f(i) : i) ? r.push(a = [i]) : a.push(i)
return r
}
```
* Body: `+52`
* Identity comparison: `-5`
* Full-length built-ins: `+6`
### Try it:
```
Array.prototype.group = function(f){
const r = []
const k = r
for(const i of this)
k!==(k=f?f(i):i)?r.push(a=[i]):a.push(i)
return r
}
console.log(
['a','c','E','G','n'].group(x => x==x.toUpperCase()),
[1,1,'1'].group(x=>x),
[3,1,'1',10,5,5].group(x=>x+2),
[{a:1,b:2,c:3}, {b:2,a:1,c:0}, {c:5}].group(x => JSON.stringify([x.a, x.b])),
[].group(x=>x)
)
```
---
# JavaScript, 48 points (56 tiebreaker)
More traditional code golf-y solution.
```
Array.prototype.group = function(f,r=[],k=r){
this.map(i=>k!==(k=f?f(i):i)?r.push(a=[i]):a.push(i))
return r
}
```
* Signature: `+9`
* Body: `+44`
* Identity comparison: `-5`
* Full-length built-ins: `+8`
### Try it:
```
Array.prototype.group = function(f,r=[],k=r){
this.map(i=>k!==(k=f?f(i):i)?r.push(a=[i]):a.push(i))
return r
}
console.log(
['a','c','E','G','n'].group(x => x==x.toUpperCase()),
[1,1,'1'].group(x=>x),
[3,1,'1',10,5,5].group(x=>x+2),
[{a:1,b:2,c:3}, {b:2,a:1,c:0}, {c:5}].group(x => JSON.stringify([x.a, x.b])),
[].group(x=>x)
)
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 90 bytes, 82 points
```
return((o,p,O)=>this.map(v=>(O=o,(o=f?f(v):v)===O?p.push(v):p=[v])))(0/0).filter(x=>x.pop)
```
[Try it online!](https://tio.run/##pVLNa9swFL/nr3g3S0xV7IZcHJQyxhj0UA9GezE@yK6cqvMsIcnGIfhvz6Q4SRuz2wRP6Ov38Z7eO@@5rYzU7q5Vr@JYqdY62DWq5M0LN5KXjbDA4PFX9kStM7LdyXqPsvJdVI7@FnuL6q6tnFQtIAwHMMJ1pgX3Ju0GRoQx3iwW5@evopat@GmUFsZJYdFXY/ieaqOccnstCBwW4MfOqE6n500YPW86kcJFCdVe6TgpIaSIJhlm2yBJ/3CNerZFGVMEKVY/1KjHaY8ZY9mDprqzb@FAs7wvvDcUL2NMa9k4YdDAtgPVSuPjRXdcTPMYkgilUY2gjdqhPOIRiSof33388NFGBT35RgOwLQyMDdSpZ@1T/catmAqxXEJ@gRYE8jP6tPQExUwkIQmJkg9i7@/K4u8KkofbOWo1oUgSkzVZfwZ/ub/CV0EzOQknJ/0kDnMAzPkOPE1Imd6TKl2N/ovCMhxVaRy2Vboeb1KftUo@UE5goGXxUYJbyhvG4GLinPv4Vxlmb/6jS8F3yLzv8eb4Fw "JavaScript (Node.js) – Try It Online")
>
> 90 - 3 (`this` counts as 1 bytes) - 5 (default `f` as `x=>x`) = 82 points
>
>
>
] |
[Question]
[
## Introduction:
Unfortunately an Accordion Solitaire Solver challenge already exists ([*Solve a game of Accordion*](https://codegolf.stackexchange.com/questions/55315/solve-a-game-of-accordion)), so instead this easier related challenge.
Let's start by explaining how Accordion Solitaire works:
1. You start with all 52 cards (or 53 if you add a Joker) in one big row.
2. You pile up cards from right to left that are either adjacent, or have two cards in between them.
1. This can either be when they are the same suit
2. Or when they have the same value
For example, let's say we start with this: `HK S8 SK DK`, then you'd have these possible game scenarios:
1. `S8←SK`, resulting in `HK SK DK`; `SK←DK`, resulting in `HK DK`; `HK←DK`, resulting in `DK`.
2. `SK←DK`, resulting in `HK S8 DK`.
3. `HK←DK`, resulting in `DK S8 SK`; `S8←SK`, resulting in `DK SK`; `DK←SK`, resulting in `SK`.
You win when every card is in a single pile in the end, so the game scenarios 1 and 3 would be a won Accordion Solitaire, but in scenario 2 you would have lost.
*NOTE: Symbols used are as follows: `H=Hearts; S=Spades; D=Diamonds; C=Clubs. T=10; J=Jack; Q=Queen; K=King; A=Ace. J=Joker`.*
PS: Irrelevant for this challenge, but added for informational purposes for those interested: if you play Accordion Solitaire with Jokers, you can only use each Joker once. The Joker will be put at the bottom of the pile when paired up. I.e. `H4 C4 S4 J` could have for example the following game scenario: `S4←J`, resulting in `H4 C4 S4` (so NOT `H4 C4 J`); `C4←S4` resulting in `H4 S4`; `H4←S4` resulting in `S4`.
## Challenge:
Given a row of cards, output all first steps we can make. So with the example `HK S8 SK DK` above, the result would be `["S8←SK","SK←DK","HK←DK"]`.
## Challenge rules:
* Not all inputs can have a move. So a test case like `H3 C7 S5 CQ` will result in an empty output, because no moves can be made.
* Jokers will be added, which can be used as any wild card, so it can always pair up with up to four other cards (depending on its position).
* Input and output formats are flexible, but you'll have to use the formats specific (with optionally `10` instead of `T`). Input can be a single space-delimited string; list of strings, characters; map with suit + value; etc. Output can be a single delimited string, pairs output to STDOUT, list of pairs, etc. (the character to indicate moves - for which I've used `←` in the example above - can also be anything you'd like, and the order of the pairs could also be reversed (i.e. `["SK→S8","DK→SK","DK→HK"]`)). Please state what you've used in your answer!
* Order of the list in the output doesn't matter (i.e. `["SK←DK","S8←SK","HK←DK"]` is valid as well).
* There won't be any test cases with duplicated cards (including Jokers). So we can assume the test cases use a single Deck of 53 cards (52 + 1 Joker). (So you could use a set instead of list for the output if it would save bytes, since all pairs will be unique.)
* You are allowed to use `10` instead of `T` if that's what you prefer. You are not allowed to use `JJ` (or anything else of 2 characters) for the Jokers; Jokers will always be a single `J`.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code (i.e. [TIO](https://tio.run/#)).
* Also, adding an explanation for your answer is highly recommended.
## Test cases:
```
Input Output
"HK S8 SK DK" ["S8←SK","SK←DK","HK←DK"]
"HA H3 ST" ["HA←H3"]
"H3 C7 S5 CQ" []
"HK S8 J C8 CK" ["S8←J","J←C8","C8←CA"]
"H5 CA SQ C9 H9 C2 CQ HJ CT SK D3 H8 HA HQ S4 DA H7 SA DK"
["C9←H9","C9←CQ","H9←HJ","C2←CQ","C2←CT","H8←HA","HA←HQ","HA←DA","HQ←H7","S4←SA","DA←DK"]
"CA C2 C3 J H2 H3 D4 H4" ["CA←C2","CA←J","C2←C3","C2←H2","C3←J","C3←H3","J←H2","J←D4","H2←H3","H2←H4","D4←H4"]
"H4 C4 S4 J" ["H4←C4","H4←J","C4←S4","S4←J"]
"H3 S3" ["H3←S3"]
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 60 bytes
```
L$w`((\bJ)|(\w)(\w)) (\w+ \w+ )?((?(2)..|(J|\3.|.\4)))
$1<$6
```
[Try it online!](https://tio.run/##JY2xCsIwEIb3PMU/VEhQAm2itiCUkoJH6lLi2KEKDi4OInTJc/kAvli86HA/x9133z1vr/vjUqaVPM7pVCyzlNPVqyinReVS4Fwjl2qlbGWltI7Sx8noqCerlBJFeSh26fMWm0QDQo0woB8EdSCDcBacbo@whRvFH/BwNRwjPOsQRrgG1MBVjIB4e/45DKhG1owIFj03rOmym68ybNhEVX7TW5AVZOFsZv0X "Retina – Try It Online") Link includes test cases. Explanation:
```
L$
$1<$6
```
Output the appropriate captures from each match.
```
w`
```
Find all overlapping matches (not just simple overlaps).
```
\b((\bJ)|(\w)(\w)) (\w+ \w+ )?((?(2)..|(J|\3.|.\4)))
```
Match either the Joker or a two-letter card, then two optional cards, then if the Joker was matched then any other card otherwise either the Joker or a card that matches either in suit or value. (I don't have to check for letters here as there can only be one Joker and the suit and rank can only match another card.)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~124~~ 119 bytes
```
lambda c:[[v,c[j]]for i,v in enumerate(c)for j in[i+1,i+3]if j<len(c)and any(d[0]==d[1]or"J"in d for d in zip(v,c[j]))]
```
[Try it online!](https://tio.run/##JY1BDoMgFAWv8sMKommquGrqorEL4xUoCyqQfqJIKDWxl6eabmfy5oUtvRbPs20feVLzUysYL0Ks5SiclHaJgOUK6MH4z2yiSoaO7MBuhwKLqsSCS7TgrpPxu1Neg/Ib1eIs21aLSi6RDGQvaDh2@oh9MdD/BWMyh4g@UUtJd4Ouho7DAH0NPYd7A31DTu8wYaKMsfwD "Python 3 – Try It Online")
Credits
* From 124 to 119 bytes by [ovs](https://codegolf.stackexchange.com/users/64121/ovs).
] |
[Question]
[
# Introduction
I have some JavaScript code that uses [`Array.prototype.map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) to map an array of functions `fns` to their return values:
```
const fns = [() => 1, () => 2];
const result = fns.map(
fn => fn()
);
console.log(result); // => [1, 2]
```
# Challenge
The argument to `map` above is `fn => fn()`. The challenge is to **rewrite this function using [point-free style](https://en.wikipedia.org/wiki/Tacit_programming)**. Your solution should work when it replaces the third line of the above program:
```
const fns = [() => 1, () => 2];
const result = fns.map(
/* your solution should work when inserted here */
);
console.log(result); // => [1, 2]
```
`fn => fn()` is not a valid solution because it defines a parameter named `fn`. Writing a function in point-free style requires writing it **without any variable or parameter names**.
Note that `map` will pass three arguments to your solution function: `currentValue: () => T`, `index: number`, and `array: Array<() => T>`. The function for the solution **must return the result of calling** the `currentValue` function, so hard-coding `1` and `2` will not help. The functions being mapped over are guaranteed to ignore their arguments and their `this` value, so calling the function in any way will work.
# Scoring
The **best answer** is the one that is represented by the **fewest tokens** when lexed. The [ANTLR 4 JavaScript lexer](https://github.com/antlr/grammars-v4/blob/cdd2a8a1cd7f08cbeef62098575a3bd2f524d5e3/javascript/JavaScriptLexer.g4) is the official lexer for the sake of objectivity, but if you know how a lexer works you should be able to estimate how many tokens some JavaScript needs without having to read that link. For example, `fn => fn()` is composed of five tokens: `fn` `=>` `fn` `(` `)`.
However, I personally think that figuring out *any* answer is the fun part, so if this problem interests you, try to solve it yourself before scrolling down and seeing the answer.
[Answer]
Based on [the answer by Rory O'Kane](https://codegolf.stackexchange.com/a/169898/44718):
>
> **10 tokens**: `Number.call.bind(String.call)`
>
>
>
[Try it online!](https://tio.run/##JY0xDsMgFEN3TuERpJaoWaP0CF06RhkIoRHVzycC0utTWjbLfrbf5mOSjf7IVw6rK8UGThkvThgxSYXxjtsFTfTzIFoeXTopV6SCejeHFMDj3BcXtTVEevG8ymeOnre/oYRq1UBOU9hkG1ADuu63PNWPfi7lCw)
It is trivial, since `Number.call, String.call`, `Object.call`, `Function.call`, `(function () {}).call`, `Function.prototype.call` are all the same.
If [Bind Operator Proposal](https://github.com/tc39/proposal-bind-operator) is accepted, this could be simplified to:
>
> **6 tokens**: `::Function.call.call`
>
>
>
[Babel](https://babeljs.io/repl/#?babili=false&browsers=&build=&builtIns=false&spec=false&loose=false&code_lz=MYewdgzgLgBAZpGBeGBtAFASmQPhgRgBoYtcYAmAXQG4AoUSWAJwFMIBXAG1hQQgDoAtgEMADulowYALmkAxdmGBQAluH7BhnThq2damOgwghOLfpxABzdKw7dDMAPROyqIhUpA&debug=false&forceAllTransforms=false&shippedProposals=false&circleciRepo=&evaluate=false&fileSize=false&sourceType=script&lineWrap=true&presets=es2015%2Ces2016%2Ces2017%2Creact%2Cstage-0%2Cstage-1%2Cstage-2%2Cstage-3%2Ces2015-loose&prettier=false&targets=&version=6.26.0&envVersion=)
BTW, if eval is allowed `eval("Number.call.bind(String.call)")` only use 4 tokens.
[Answer]
This combination of [`Function.prototype.call`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call) and [`Function.prototype.bind`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) works:
```
Function.prototype.call.call.bind(Function.prototype.call)
```
**16 tokens:** `Function` `.` `prototype` `.` `call` `.` `call` `.` `bind` `(` `Function` `.` `prototype` `.` `call` `)`
```
const fns = [() => 1, () => 2];
const result = fns.map(
Function.prototype.call.call.bind(Function.prototype.call)
);
console.log(result); // => [1, 2]
```
# Explanation
`Function.prototype.call` is not a solution on its own because `map` will call `call` with its `this` value set to `undefined`. `call`’s purpose is to call the function in `this`, so when `this` is `undefined` a `TypeError` is raised.
Similarly, `Function.prototype.call.bind(Function.prototype)` is insufficient because the `call` function is called with `this` set to `Function.prototype`, and the function you want called set to the first argument. Calling `Function.prototype()` with any arguments returns `undefined`, so the function will return `undefined` instead of `1` or `2`.
My solution works by using the second `call` to make the `fn` argument the `this` of the first `call`, like this:
```
fn => Function.prototype.call.call(fn)
```
Now the first `call` can do what it is made for, calling the argument in its `this` value.
] |
[Question]
[
It is widely known that Santa Claus delivers presents to houses all over the world in December. However, not many people know what he does during the rest of the year. You see, Santa enjoys a jolly good prank, and he'll often find himself pranking entire cities when he's not busy making or delivering toys.
One place that he particularly enjoys pranking is the South Pole. You might be saying, "The South Pole isn't a city." You would be right, but Santa doesn't care. There are `h` houses in the South Pole, which are conveniently numbered from `1` to `h`. Whenever Santa is in the mood for pranking, he'll start at a particular house, s. He rings the doorbell, then runs to another house.
He always visits houses in order, but just so he doesn't arouse suspicion, he only knocks on every `k`th house (for example, every `2`nd or `3`rd house), where `k` ≥ `2`. This is because the residents (who are penguins) would know that something's up if one or both of their next door neighbors were pranked as well. Once Santa pranks `p` houses that day (or passes house number `h`), he goes back home to the North Pole.
After pranking houses for `d` days, though, Santa feels bad for pranking the penguins so many times. To make things right, he decides that next Christmas he will award the biggest and best gift to the penguin who got pranked the most. If there are multiple houses that got pranked the most, he will award the gift to the penguin in the lowest numbered house.
**The Problem:**
Help Santa by telling him which house should receive the biggest and best gift the following Christmas. Santa, of course, wants to make amends each and every year so he needs your suggestion for each one.
**The Input:**
Two integers, `h` and `d`, representing the number of houses and the number of days that Santa pranked the South Pole that year, respectively. Additionally, take in multiple sets of three integers, `s`, `k`, and `p`, denoting the starting house, the number representing his frequency of visiting houses (he skips `k`-1 houses), and the maximum number of houses he pranks that day. Note that he will visit p houses unless he passes the very last house. You may take these inputs in any reasonable format.
Output `g`, where `g` is the house number that should receive the biggest and best gift (the house that got pranked the most, and the lowest house number in the case of a tie). **Note that you may not use zero-based indexing, because Santa doesn't know what a computer is.**
Test cases:
```
4 3
1 2 1
3 4 2
2 2 2
Output: 1
10 2
2 3 2
3 2 5
Output: 5
50 100
10 10 36
17 7 1
37 2 19
28 2 49
29 3 29
48 3 12
35 3 25
28 4 20
38 8 27
39 3 19
26 4 9
20 7 8
47 10 1
6 10 43
31 3 29
35 2 23
24 9 44
10 3 25
29 10 37
32 5 47
21 5 31
44 5 43
46 4 47
16 10 5
5 3 18
7 8 10
48 5 31
29 4 7
31 8 5
23 9 43
34 8 4
41 10 38
30 6 23
17 7 1
43 5 24
29 2 37
22 10 19
17 6 43
37 3 22
42 10 9
48 4 47
11 6 3
29 7 42
11 9 28
3 4 9
39 9 7
20 9 5
47 5 29
20 4 4
44 10 30
30 6 21
39 10 38
7 9 18
32 10 47
14 9 13
7 2 8
44 3 19
40 4 12
4 10 12
3 5 46
3 5 37
29 9 45
16 4 26
27 9 32
37 10 16
30 5 39
36 2 26
25 2 28
13 3 16
8 8 27
27 6 29
39 10 10
34 7 47
5 4 17
39 2 9
45 2 24
4 6 11
8 10 24
50 7 30
7 4 37
35 10 44
35 9 28
49 10 7
20 5 17
30 4 50
18 7 4
4 7 14
38 9 40
27 3 15
39 5 13
8 2 46
15 4 13
21 9 49
28 6 29
48 5 35
8 8 5
27 3 41
35 10 23
14 4 15
12 2 22
Output: 48
```
**Scoring:** Number of bytes. Subtract 20 bytes from your score if your program can handle inputs of up to 100,000 (both days and houses) in less than 5 seconds on a standard desktop PC. Note that in all these inputs k will be less than or equal to 10.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 20 [bytes](https://github.com/DennisMitchell/jelly)
```
Ḣrm⁸Ḣ¤ḣ⁸
ç€FµĠLÐṀḢḢị
```
A dyadic link taking a list of lists of numbers, the list of `s,k,p` values, and a number `h` (`d` is just the length of the list so is redundant), returning the house number.
**[Try it online!](https://tio.run/##PVMxbtxADOzzli1ELlcrfcCVf3C4Mk3gNOncJW7d@AlBHCBN2gAXpLPzkfNH5JnhSoAAEdzlzHDI/fTx7u5@266XH18@v3274P/y83p5Rvjh9dfbw@@blz//v9@@Pl3/fsUZv3@P27adTjYVfHU@l5P10oshqL14sRWRL4hC0VpqcUaxIDLnvcZcy3tRfGJuKajpjFiRKDNOFUxgWIjRyUqumUFU3redAbhenDlHXYmguOngWqVYFF5aCUZuiCoBI5hjcZBWpyYWFlOxUQF0IJftjEoAR@mpZNFtr6SXuECKOsLETog6lTllHs5FBZhHgnmKdFeva96bB15nOzQxdDyM3fUa7tVE6SU8U0AU7TAT/q6SC1dXyYWrLR1EKlJuSO50yLWs3HvoKJUfVTKSnaZb1annuGIfZRBYwxdwrgENn0eQLVNatHQei8FDJ1X17J2lc2pCibqZOXNd1PRJa5W0zB1L5XTQ16MJjRDD6Sm9Ud1YPk9ThSYrUGkmMBQq1biPMgf1Y6WafIgMh@UhruF1Gwx0orHWFtKLAZ1FPgL0P6VetNBSUUtX9ab04CS35vqu450te4O5mG1033awsENl7l4QRF47W/XzeWvTOw "Jelly – Try It Online")**
### How?
Builds lists of house numbers visited each day, then finds those visited the most and returns the minimal numbered one.
```
Ḣrm⁸Ḣ¤ḣ⁸ - Link 1, get houses visited on one day: list, [s,k,p]; number, h
Ḣ - head = s (modifies the list to become [k,p])
r - inclusive range = [s,s+1,s+2,...,h]
¤ - nilad followed by link(s) as a nilad:
⁸ - chain's left argument = [k,p]
Ḣ - head = k (modifies the list to become [p])
m - modulo slice (take the 1st item then every kth item of the range)
⁸ - chain's left argument = [p]
ḣ - head to index (vectorises) (take the first p items, or all if less
- this will yield a list of length 1 containing the truncated list)
ç€FµĠLÐṀḢḢị - Link: list of lists [[s1,k1,p1],[s2,k2,p2],...]; number, h
ç€ - call the last link as a dyad for €ach
F - flatten into a single list (all the houses visited)
µ - monadic chain separation, call that v
Ġ - group indexes by value (indexes of smallest houses will go first)
ÐṀ - filter to keep only those with maximal:
L - length (the groups containing indexes of houses visited most)
Ḣ - head (get the first such group)
Ḣ - head (get the fist index from the group)
ị - index into v (get the house number)
```
[Answer]
# [Python 3](https://docs.python.org/3/), 158 bytes
```
r=range
def f(h,_,x):
L=[0]*h
for s,k,p in x:
n=0
for i in r(s,h+1,k):
if n>p:break
L[i-1]+=1
n+=1
return[i for i in r(h)if L[i]==max(L)][0]+1
```
[Try it online](https://tio.run/##TU1BCsMgELznFXvUZgsxoZeAfUF@IFJSqlVCN7JJIX291Z56mWFmZ2bTZw8rDTmz5pmernk4D14EvOEhxwYmbTp7Cg34lWHDBRNEgqNcgHRXsPqxeiw2DK3CpdYAoge6pvHObl6qnkw8K9tqVQX9mN3@ZjLxfyPIUixZq/VrPsQkbfnfqpw40i68UB32aEyPA/YWTUG8WCtlzvkL)
So this is barely golfed or optimized, but it's a start. I may return to it if I think of better ways to do it. And it doesn't get the bonus. v\_v
[Answer]
# [Python 2](https://docs.python.org/2/), 78 bytes
```
h,a=input();l=[]
for s,k,p in a:l+=range(s,h+1,k)[:p]
print max(l,key=l.count)
```
[Try it online!](https://tio.run/##PVPLjhpBDLzzFaM9gdaKprvd8yDiL3JDHBCZBAQ7IBaU3a8nVXbPSAiMu11VLrtv34/jdYyvw/X3sHl7e3sdZb85jbfnY7n6edlsd4s/13v1KWe5Vaex2q8v75v7fvw7LD/l@B7kvNqub7vF7X4aH9XH/mt5kfPwvbn8OFyf42P1AuTi3/F0Gapf9@ewXlTV8DUcKtK9VLbbIFHCTrZJVCJ@I/7H3W4RahxGSZbEt2QkM5M4wSc1yIdWWq9uCdOzvkOkFvWsZqQdomBAmbns90BYM9cJalpGrHCUBqcW1GDoiNGSlVwNA028HyYG4EI2cxF1okpx9czVm2KjQCOijGJAlAioyhyLlbR2GoyFxVQcqAA6kPN2SiWAVVpX0tntmEhv4hQp6tBg7IRItTQuc3ZOE8CiOlh0kTFar73fawpey3ZootpxMXbSG3AvOUorGj0FxK7Mtnd/e5MLV3uTC1ezO4iUulw1ufUsN3jl1EOLUvMjmQxnp@kh2Wn0cek0SiWwDd@AfQ1oeFMCb5nSNLvzWAweRlKl6L2ztHFNKLFuGs7cLtr0SRsSaZmblyrSwdjPTdgIMZzWpWeqK8sX3VRDMytQGYKBodBSmfto5qC@rFQ2H9TDYrkaV/E6FwY6kVkbOtIbAzpTfwTov3a9aCG7ouyu2puyB2dyk69vX95ZNzXoi5lL93kC0zCr9N1TgpjX9trx3P8D "Python 2 – Try It Online")
Takes input without the numbers of days.
] |
[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/129525/edit).
Closed 6 years ago.
[Improve this question](/posts/129525/edit)
## Write a program, that sends its own source code over network.
Network example is TCP/UDP or web socket. Ethernet, Bluetooth, Wi-Fi and internet over USB are allowed.
No need to write receiver program. You can use any encoding protocol, but decoder will be realizable.
# Rules
* Network **is not** a stdout, screen, USB, UART, GPIO or same.
* The program must be at least 1 byte long.
* No input or accessing source from file system.
* No extra software to send stdout to network like **ssh**.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest code wins.
[Answer]
# Java 8, 662 bytes
```
import java.io.*;import java.util.*;interface M{static void main(String[]a)throws Exception{String s="import java.io.*;import java.util.*;interface M{static void main(String[]a)throws Exception{String s=%c%s%1$c,x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(%1$c%1$c));!x.equals(s);s=s.join(%1$c%1$c,l));ObjectOutputStream o=new ObjectOutputStream(new java.net.Socket(%1$clocalhost%1$c,0).getOutputStream());o.writeObject(s);o.flush();}}",x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(""));!x.equals(s);s=s.join("",l));ObjectOutputStream o=new ObjectOutputStream(new java.net.Socket("localhost",0).getOutputStream());o.writeObject(s);o.flush();}}
```
Creating a [quine](/questions/tagged/quine "show questions tagged 'quine'") in Java is verbose as F... >.>
**Explanation:**
['Try it' here.](https://tio.run/##vU89T8MwEP0rxiKSg4IFgi3KwMAG6tARMbiu2zp1csZ3boKq/vbgNAKBUJcKMVjWvbv3VaudugZv2nq5HQbbeAjE6gRKC/Kq/A5Esi5B2ilE9rz3ceGsZkiK0rcDu2SNsq2YU7Dt@uVV5bQJ0CF77LXxZKHdTyuGFf8vo0xnmN1e6qKvsEK5gtAoEljc3ReYl2kUTxaJueohBPWOUuE4i16id5bESB1fnpcXvTRvUTkUiThq1ZAyfB4ULp3MFrXRNIvkI6UERjUMqtZ07PdCjPCxbGtIzkFvzeTmQCu3AaSj6k0u1@YnMfmA7IIlM6mOcUCuXMSNyMvDgZ9ZlfOTJTn/k3r8qxs/p9gwfAA) (Will result in `java.net.SocketException: Permission denied`.)
```
import java.io.*; // Required import for ObjectOutputStream
import java.util.*; // Required import for List and Arrays
interface M{ // Class
static void main(String[]a) // Required main-method
throws Exception{ // required throws for the Stream and Socket
String s="import java.io.*;import java.util.*;interface M{static void main(String[]a)throws Exception{String s=%c%s%1$c,x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(%1$c%1$c));!x.equals(s);s=s.join(%1$c%1$c,l));ObjectOutputStream o=new ObjectOutputStream(new java.net.Socket(%1$clocalhost%1$c,0).getOutputStream());o.writeObject(s);o.flush();System.out.println(s);}}",
// Quine-String
x=s=s.format(s,34,s);for(List l=Arrays.asList(x.split(""));!x.equals(s);s=s.join("",l));
// Quine-magic
ObjectOutputStream o=new ObjectOutputStream(new java.net.Socket("localhost",0).getOutputStream());
// Output stream to http://localhost:0000/
o.writeObject(s); // Write to the output stream
o.flush(); // And send it
} // End of main-method
} // End of class
```
* The String `s` contains the unformatted source code.
* `%s` is used to input this String into itself with the `s.format(...)`.
* `%c`, `%1$c` and the `34` are used to format the double-quotes.
* `s.format(s,34,s)` puts it all together
Slightly modified with `print` to prove it's a quine:
[Try it here.](https://tio.run/##vVCxTsMwEP0VY1HJqYILgi3KwMAG6tARMbiu2zh1csZ3blNV/fbgtAKBUBdUMVjWvXfv3b2r1UbdgDdtvVj3vW08BGJ1AqUFOS6@A5GsS5B2CpG97H2cO6sZkqL0bcAuWKNsK2YUbLt6fVMZVQG2yJ46bTxZaPcnimHJ/2vQSI9wdHet867EEuUSQqNIYH7/kGNWpFI8WyTmyscQ1A6lwqEWnUTvLIlBOrwsK646ad6jciiScPCqIe3w2ZC71DIZT@e10TSN5COlHYxqGJSt2bLfhBjgY9zWkJyBXpvTPAdauQqQjr63mVyZn8I0CeQ2WDIn12EhkEsXsRJZMZ7MdkimkRBJ@nSGI3848D@egPOz4Tm/UGz@lZlfLnDffwA)
] |
[Question]
[
For [a story I'm writing](http://meta.worldbuilding.stackexchange.com/questions/4639/my-alien-message-series), I needed to convert 101⅐ (101 + 1/7 if that doesn’t show up for you) into base 47.
Expressing an integer in some base brings back memories of first learning how to program back in the days of 8-bit systems; it’s a fairly easy exercise. Doing so using a floating-point format is a bit harder, though. The final twist, identifying the repeating digits, is more challenging to do elegantly.
So I thought I’d do it in a different language from what I’m used to, just for fun and learning the new dialect. And I thought it would be good to share, so here I am. The vast majority of the posts here are (char or byte of source) code golf, but I’m more interested in an elegant expression in the target language. Cyclomatic complexity isn’t a category, but [atomic-code-golf](/questions/tagged/atomic-code-golf "show questions tagged 'atomic-code-golf'") is pretty close.
---
The program should take a *rational number* in a natural way, such as supplying three integers on the command line of the script invocation or standard input. This does not count towards the score (nor does the error checking and defaults if you give it one value only). The *function* (or part that is counted for score) should receive the three values; e.g. 101,1,7 for the example above.
The output is a sequence of code points that are transliterated into *text output* as follows:
* digits 0 through 9 inclusive: ‘0’ through ‘9’ in the normal way
* digits 10 through 46: express as ‘[10]’ through ‘[46]’
* negative sign: the normal ASCII ‘-’
* separator: ‘:’
* prefix: ‘#’
A number starts with the prefix ‘#’ and has up to three parts, separated by ‘:’. Leading parts are omitted if zero.
The basic natural number (BNN) is encoded using the digits in base 47, outputted in little-endian. That is, 99181 = 11×470 + 42×471 + 44×472 so the digits, in order output, are [11][42][44].
The last (possibly only) part of a number is an integer, which is a leading ‘-’ if the value is negative, followed by the digits of the BNN. So, 99181 would be encoded as `#[11][42][44]` and −99181 would be encoded as `#-[11][42][44]`.
The middle part, if needed, is an exponent as for scientific notation. It states which power of the base (position) is the first digit listed. In the case of integers, this is 470 so the 0-valued part is omitted.
Suppose you divide that by 47, shifting the radix point by one. That is, 99181 ÷ 47 is the same digits but starting with 47−1; that is, 11×47−1 + 42×470 + 44×471, and the output becomes `#-1:[11][42][44]`. There are two parts, the first is the encoding for the integer −1, and the second is the digits as before.
Now it comes out so neat only if you divide by some power of 47. Normally, a rational number made of small components will end up with a repeating sequence of digits. In decimal, for example, ⅓ is .3333… and ⅐ (1/7) is .142857142857142857… in the first case one digit repeats, in the second case 6 digits repeat.
In the alien real number format, the first part, if present, states how many digits are to be repeated. So, the number 8½ would have a single digit [23] repeating forever, so we just encode one of them and state that 1 repeats: `#1:-1:[23]8`. The first part is 1 (the encoded BNN for the value 1) which means that one digit is to be repeated. The second part (negative sign and BNN) indicates that the first digit given is the 47-1 position. The third part is the two digits needed: 26×47-1 + 8×470.
---
Somebody should check my results, but I think the correct output for (101 1 7) is:
`#6:-6:[20][13][40][26][33]672`.
[Answer]
## Batch, 531 bytes
```
@echo off
set q=
set s=
set m=
if %1 lss 0 set m=-
set/ai=%m%%1,n=%2,d=%3,p=0
:i
set/ar=i%%47,i/=47
if %r% gtr 9 set r=[%r%]
set s=%s%%r%
if %i% gtr 0 goto i
:p
if %n%==0 goto n
set/ao=n,g=d%%47
if %g% gtr 0 goto g
set/ap+=1,d/=47,r=n/d,n%%=d
if %r% gtr 9 set r=[%r%]
set s=%r%%s%
goto p
:g
set/aq+=1,p+=1,r=n*47/d,n=n*47%%d
if %r% gtr 9 set r=[%r%]
set s=%r%%s%
if %n% neq %o% goto g
if %q% gtr 9 set q=[%q%]
set q=%q%:
:n
if %p% gtr 9 (set q=%q%-[%p%]:)else if %p% gtr 0 set q=%q%-%p%:
echo #%q%%m%%s%
```
Takes three parameters, whole number, numerator, denominator representing a mixed number in its lowest terms.
] |
[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/64575/edit).
Closed 8 years ago.
[Improve this question](/posts/64575/edit)
`map` is a very basic yet important function in functional programming.
All FP programming languages have it built-in but it is always fun to see how shortly you can define it yourself.
This will be scored in **AST nodes**, not bytes.
A token is the second-smallest building block of a program, over characters.
A token is:
>
> anything that would be a distinct node if you drew a tree representing the source code
>
>
>
This scoring gives no benefit to single letter AST nodes names, and values succinctness as Paul Graham likes (this definition of AST nodes is his).
Haskell has this super cool definition:
```
zipWith ($) . repeat
```
And my lisp-ish AST of it (not required in your answer, just to show it visually)
```
Apply (Apply (Var ".") (Apply (Var "zipWith") (Var "$"))) (Var "repeat")
```
That is 7 tokens. (`Var x` counts as 1)
I did not write it, so I do not post it as an answer.
Example:
```
(zipWith ($) . repeat) (* 3) [1, 2, 3] -- [3, 6, 9]
```
`map` should be defined as a (named or unnamed) function taking two arguments, the function and the list.
May the most AST nodes-succint code win!
[Answer]
# Mathematica, ~~36~~ 11 nodes
```
Thread@#@#2&
```
The `FullForm` of this program is:
```
Function[Thread[Slot[1][Slot[2]]]]
```
which has 4 symbols, 2 numbers, and 5 function applications.
[Answer]
# Python 3, 19 nodes.
```
lambda f, x: [f(y) for y in x]
```
Fairly self-explanatory. Applies `f` to each element of `x` and then returns the resulting list.
Interestingly, this code also uses only 19 AST nodes:
```
def map(f, x):
for y in x:
yield f(y)
```
I'm not totally sure if I'm counting the nodes correctly, because this is the first time I've worked with an AST. But this is what I used to count:
```
import ast
code = '''
lambda f, x: [f(y) for y in x]
'''
print sum(1 for node in ast.walk(ast.parse(code)))
```
[Answer]
## Haskell, 11(?) nodes
```
flip foldr ([]).((:).)
```
Not sure about the node count (6 symbols plus 5 function applications?).
] |
[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/57566/edit).
Closed 8 years ago.
[Improve this question](/posts/57566/edit)
*The question uses C to formulate the problem, but solutions in any language can be accepted. At the end of the question you can find a pythonic version.*
As part of a bigger software, we have a C function:
```
void wrapper(void* p);
```
Which is a wrapper function around the C function:
```
void handler(void* p);
```
`wrapper()` is triggered by an external effect (hardware interrupt, unix signal, it doesn't matter), which also provides a `p` as its argument. The triggering can happen after the execution of any CPU instruction, *even if `wrapper()` or `handler()` is being executed*. The triggering happens similarly to the interrupt requests in a cpu, or to the signal handlers in unix: after `wrapper()` returns, the execution continues from exactly the same CPU state as the triggering found it.
We don't know what does `handler()`, but we know that it doesn't interact with the triggering mechanism.
As a help, we have
```
void swap(void **a, void **b);
```
which swaps the contents of two `void*` pointers in a single cpu instruction.
The solution of the problem is a `wrapper()` function, which "serializes" `handler()`: it makes sure, that `handler()` never is called in multiple times: every new `handler()` will be called only after the previous returned.
Trigger can't be lost: for every `wrapper()`, exactly one `handler()` must be called. It shouldn't be called from the same `wrapper()` which was actually triggered, but `p` can't be lost.
Similar solutions in practical situations often block the triggering for a short period, here it is impossible.
If needed, `malloc()`, `free()` and `NULL` (`==(void*)0`) can be used, but out of it, no library calls. These functions are considered reentrant (if triggering happens in them, they will work correctly). Especially any direct or indirect usage of any multithreading isn't allowed.
There is no speed criteria for `wrapper()`, but it must be ready in a finite time. We know, that the triggering won't happen so fast to cause some hardware/stack/etc. overflow. `wrapper()` must handle any deep of reentrancy.
Any language can be used for the task (incl. asm or interpreted languages), but no language construction or api calls which would make the task essentially easier, as in C.
*The `handler()` calls don't need to happen in the same order as their corresponding `wrapper()` was triggered.*
The solution is an implementation of `wrapper()`.
**Analogous problem in Python:**
Look for the signal handlers module in python ([here](https://docs.python.org/2/library/signal.html)). This what this problem is about. Essentially, we have a
```
def wrapper(p):
..the solution...
```
What is a wrapper around
```
def handler(p):
...we don't know what is here...
```
The execution of `wrapper` is triggered by an external event. It means, that it can happen *any time*, *even while we are in `wrapper` or in `handler`*. If the triggering event happens, `wrapper` will be called. After it returns, the normal program execution will continue. The task is to implement `wrapper` in a such way, that `handler` won't run multiple times in the same moment. I.e. the next `handler` will be called only after the previous returned, even if the triggering happens while the `wrapper`(s) of previous trigger(s) run.
No python API call or external module can be used, with the single exeception of a
```
def swap(a, b):
```
...which exchanges the values of `a` and `b` in a single instruction (equivalent of a `tmp = a; a = b; b = tmp`, but it does in a single moment, without a triggering would be happened).
*Bonus Python problem:* the internal Python functions which handles the lists, dicts, etc, *they all aren't reentrant*. This means, if you call `mylist.append()`, it is possible that the trigger will happen during the execution of the `append()` method. If another `wrapper()` or `handler()` try to do *anything* with a such list, your program will segfault and solution won't be accepted. The case is the same for every higher-level language. In short: *if you use \_any\_ higher level language construct, i.e. list/dict/object/etc, you need to make sure that it won't be used by any other `wrapper` which is triggered meanwhile.*
**The objective win criterion:**
Afaik, this is a hard problem. If anybody can find a solution, is already a big success (to me was it around a week to find one), and on my opinion, there won't be a big difference between the different results. But it is required here to have an "objective winning" criterion, and so, lets say "the shortest solution in bytes" is the winner.
[Answer]
# C, 149 bytes
*Note:*
*This seems to be a pretty controversial challenge, so I might be treading on thin ice here :)*
*To make things clear, as far as I understand, the OP meant for the problem to be strictly single-threaded, which simplifies matters, since invocations of `wrapper()` can only interleave in an all-or-nothing fashion; if that's not the case, then this solution is wrong.*
*The so called "interrupts" that trigger `wrapper()` are assumed to have the same semantics as C signals, as defined by the C standard, except that, as part of the hypothesis of the challenge, `malloc()` and `free()` can be called, and `swap()` can be used to access objects of type `void* volatile` with static storage duration, during the execution of their handler.*
*(notwithstanding, the golfed version invokes all kinds of UB that aren't directly relevant to this challenge.)*
```
P B;wrapper(p){P c=malloc(8);P b=c,n=c;*c=0;c[1]=p;while(c=n){S;if(b)return*b=c;handler(c[1]);S;n=*c;free(c);}}
```
Compile with: `gcc -c -w -m32 "-DV=volatile" "-DP=int*V*V" "-DS=swap(&b,&B)" wrapper.c`.
Look below for a test program to link against.
(The calculated code size is the size of the snippet, and of the three `-D...` arguments, not including the quotes.)
## Ungolfed
We use a queue to store pending `handler()` invocations.
Several queues may exist simultaneously, but at most one may be active at any given time.
When `wrapper()` is invoked, if a queue is already active, we add an item at the back of the queue and return immediately.
Otherwise, we start a new queue, and handle all of its items, until it empties;
during the handling of a queue item (i.e., during an invocation of `handler()`), we make the queue active, so that nested invocations of `wrapper()` don't call `handler()` themselves;
however, while fetching the next item, we deactivate the queue, so that nested invocations of `wrapper()` start their own queue, instead of modifying the one we're currently inspecting.
```
#include <stddef.h> /* NULL */
#include <stdlib.h> /* malloc(), free() */
void swap(void* volatile*, void* volatile*);
void handler(void* p);
/* Each queue item contains an argument, `p`, for the invocation of `handler()`,
* and a pointer to the next item. The last item in the queue has a NULL `next`
* pointer.
*/
struct queue_item {
struct queue_item* volatile next;
void* p;
};
/* Points to the last item in the currently active queue, or NULL if there is no
* active queue.
*/
static void* volatile active_queue_back;
void wrapper(void* p) {
struct queue_item* current;
void* back;
/* We allocate a new queue item for the current invocation of `handler()`.
*/
current = malloc(sizeof(struct queue_item));
current->next = NULL;
current->p = p;
/* We make the new item the back of the active queue, by assigning it to
* `active_queue_back`, while at the same time fetching the previous value
* of `active_queue_back`.
*/
back = current;
swap(&back, &active_queue_back);
/* `back` now holds the previous value of `active_queue_back`. Since the
* swap is atomic, no two interleaving invocations of `wrapper()` see the
* same previous value, and no item is lost.
*/
/* We check if there was an active queue prior to the current invocation of
* `wrapper()`, that is, if the previous value of `active_queue_back` is not
* NULL.
*/
if (back != NULL) {
/* If there was an active queue, we pass ownership over the new item
* to the previously active queue (essentially making it active again,)
* by linking it after the previous back of the queue. The owner of the
* active queue is now responsible for handling, and disposing of, the
* item, or, alternatively, for handing it over to someone further down
* the line.
*/
((struct queue_item*) back)->next = current;
/* Note that any reinvocation of `wrapper()`, following the preceeding
* swap, will have added a queue item at the back of our newly allocated
* one, directly or indirectly. Ownership over these items is
* transitively passed to the owner of the active queue as well.
*/
} else {
/* If there was no active queue prior to this invocation, we take over
* the queue, processing its items until it empties.
*/
while (1) {
struct queue_item* next;
/* At the beginning of each iteration of the loop, we own the active
* queue, `current` points to the current queue item (which is
* initially the item created at the beginning of the function), and
* `back` is NULL.
*/
/* We can now call `handler()` for the value of `p` associated with
* the current item. Note that any reinvocation of `wrapper()`,
* from this point until the following swap, sees an active queue,
* and therefore will not call `handler()` itself, but will rather
* add an item at, ultimately, the back of our queue.
*/
handler(current->p);
/* In order to safely fetch the next item of the queue, we need to
* make sure that no one else modifies the queue while we're at it.
* To do that, we assign NULL to `active_queue_back` (recall that
* `back` holds NULL at this point,) while fetching its current
* value into `back`.
*
* Any reinvocation of `wrapper()`, from this point until the
* following swap, will see no active queue, and hence will start
* its own independent queue, process it until it empties, and leave
* `active_queue_back` NULL again, before control returns to the
* current invocation.
*/
swap(&back, &active_queue_back);
/* We free the current item and move on to the next one. If the next
* item is NULL, we terminate the loop.
*/
next = current->next;
free(current);
if (next == NULL) break;
else current = next;
/* We restore the previous value of `active_queue_back`, so that our
* queue is active again. Recall that `active_queue_back` is NULL at
* this point, so `back` becomes NULL after the swap.
*/
swap(&back, &active_queue_back);
}
}
}
```
This program can be compiled with `gcc -c -m32 wrapper.c`, instead of the golfed version.
(Since this version doesn't rely on any shenanigans, unlike the golfed one, it can be compiled without `-m32`; in this case, don't use `-m32` for the test program either.)
## Test Program
The following program is a very rudimentary test for `wrapper()`.
It's not meant to be thorough, nor does it rely on completely defined behavior;
rather, its main purpose to show `wrapper()` in action.
Compile with: `gcc -m32 -otest wrapper.o test.c`, in a POSIX environment.
Run with: `./test`.
The program triggers `wrapper()` upon receipt of SIGINT (usually, Ctrl + C), and has `handler()` print a message, and sleep for one second (during which SIGINT may be sent again).
You can terminate the program by sending it SIGQUIT (usually, Ctrl + \).
```
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <time.h>
#include <signal.h>
#include <unistd.h>
void wrapper(void* p);
void swap(void* volatile* a, void* volatile* b) {
void* t = *a; *a = *b; *b = t;
}
void handler(void* p) {
struct timespec tp;
printf("handler(p = %tu) entered. Sleeping for 1 second...", (uintptr_t) p);
fflush(stdout);
tp.tv_sec = 1; tp.tv_nsec = 0;
while (nanosleep(&tp, &tp));
printf(" handler(p = %tu) returned.\n", (uintptr_t) p);
fflush(stdout);
}
static void signal_handler(int signum) {
static volatile sig_atomic_t n = 0;
wrapper((void*) ++n);
}
int main() {
struct sigaction sa = {};
sa.sa_handler = signal_handler;
sa.sa_flags = SA_NODEFER;
sigaction(SIGINT, &sa, NULL);
while (pause());
}
```
] |
[Question]
[
**This question already has answers here**:
[Show Ulam's spiral](/questions/4577/show-ulams-spiral)
(6 answers)
Closed 9 years ago.
**The challenge**
Get familiar with the [Ulam spiral:](http://en.wikipedia.org/wiki/Ulam_spiral#Construction)
The aim is to print the spiral like in the picture above!
**Rules**
Write a function `ulam(n)`
where n is a odd positive integer and describes the size of the grid to print.
All non-primes numbers should be replaced with | horizontal and - vertical as in the picture above following the spiral. (Corner elements belongs to the vertical)
All numbers need to take the same amount of space visually and smaller numbers are right centered vertically:
`1000
100
10`
`10` needs two spaces on the left and `100` needs one space left.
This property depends on the biggest number you have to calculate.
Example: (n=3)
```
- - 3
| |
7 - 2
|
- -
```
The test for primes/sieve you have to write yourself.
Smallest byte code wins.
**Bonus**
- 25 if you can make it more pretty find some symbols so that - and | takes the same space (-25 more if you can find a pretty corner symbol) and the symbol should show the line where the spiral evolves.
[Answer]
## Python 3 - 506 479 bytes
```
q=range
def p(n):
for d in q(2,n//2+1):
if n%d==0:return 0
return 1
w=int(input());m=w**2;z=len(str(m))
def k(n):
if n==1:return'-'*(z-1)+'>'
if p(n):return str(n).zfill(z)
return'.'*z
l=[k(n+1)for n in q(m)];s=[[0for n in q(w)]for n in q(w)];x=y=w//2;t=[n//2for n in q(2,w*w)];c=[[1,0],[0,-1],[-1,0],[0,1]];j=p=0
for r in t:
d=c[p%4];p+=1;i=0
while i<r and j<m:
s[y][x]=l[j]+' ';x+=d[0];y+=d[1];i+=1;j+=1
s=[''.join(l)for l in s]
for l in s:print(l)
```
I am not sure if the byte count is correct.
Also, this can most likely be made shorter (I'm new to Python).
Right now I'm just substituting all non-primes with periods. You can change this to any character.
*Note*: You should only enter odd numbers as input, as otherwise the program breaks.
Furthermore, my function to determine whether a number is prime is the most primitive it can be, for the sake of less characters, so it is not efficient. Though it ran just fine on my computer with input values less than 100 in just under a second.
*Note*: Input values above 25 or 30 won't display correctly unless you have a ridiculously wide screen.
] |
[Question]
[
Write a [quine](http://en.wikipedia.org/wiki/Quine_%28computing%29) that
1. Writes its source code to disk
2. Recursively executes the written source code
3. Produces some variation to the code the third time (so not a true Quine)
4. Stops recursively calling itself the fifth time
Bonus points for leaving nothing on disk after execution.
[Answer]
## TCL 220
```
proc a b {
if {"$b"=="bb"} {
rename puts w
rename p puts
set b \;exit
}
puts [set q [open [incr ::i] w]] "proc a b \{[info body a]\};a b"
catch {rename puts p}
proc puts {n m} "p \$n \${m}$b"
close $q
source $::i
};a b
```
The code generates files 1, 2, 3 and 4. The variation is only present in 2, the others are equivalent to the original.
[Answer]
## PHP 643
```
<?
$c=1;
$o="<?\n\$c=".($c+1).";\n";
$m="quine";
$s=array(
'$o="<?\n\$c=".($c+1).";\n";',
'$m="quine";',
'$s=array(',
');',
'if($c==3)$s[1]="\$m=\"bip\";";',
'for($i=0;$i<3;$i++)$o.=$s[$i]."\n";',
'for($i=0;$i<count($s);$i++)$o.=chr(39).$s[$i].chr(39).",\n";',
'for($i=3;$i<count($s);$i++)$o.=$s[$i]."\n";',
'echo $m."\n";',
'if($c<5){file_put_contents("q$c.php", $o);echo `php q$c.php`;}',
);
if($c==3)$s[1]="\$m=\"bip\";";
for($i=0;$i<3;$i++)$o.=$s[$i]."\n";
for($i=0;$i<count($s);$i++)$o.=chr(39).$s[$i].chr(39).",\n";
for($i=3;$i<count($s);$i++)$o.=$s[$i]."\n";
echo $m."\n";
if($c<5){file_put_contents("q$c.php", $o);echo `php q$c.php`;}
```
Output:
```
quine
quine
quine
bip
bip
```
The variation in the code is produced in the 3rd iteration and is then only noticeable in the echoes of the 4th and 5th iterations.
[Answer]
## [GTB](http://timtechsoftware.com/?page_id=1309 "GTB"), 19
```
X+1→X@X<15$@X=13:1&
```
**Explanation**
X starts by default at 10, so we increment X once. Then, if X<15 check if X=13. If X=13, change the code. Then dump it all to memory.
[Answer]
In Squeak 4.x **Smalltalk**, it's not golfed, but there is a **299 chars** version below
Compile this method in Object:
```
quine
[| value morph |
value := (((self negated raisedTo: self - 1) / 15) exp exp - 1) reciprocal significand rounded reciprocal.
morph := ToolSet inspect: value.
[(Delay forSeconds: value reciprocal * 5) wait.
morph delete] fork.
World displayWorld.
(Delay forSeconds: 1) wait]
on: Error
do: [:exc |
FileDirectory default deleteFileNamed: 'quine'.
^self].
(FileStream forceNewFileNamed: 'quine') nextPutAll: thisContext method getSource; close.
^self class newCompiler
evaluate: ((FileStream oldFileNamed: 'quine') contentsOfEntireFile lines allButFirst reduce: [:a :b | a , b])
for: self + 1
```
Then evaluate '1 quine' where you want.
Each evaluation differs, because it is evaluated with incremented receiver.
( `evaluate: ... for: self+1` )
The awfull expression computing the value is different for 3 (lead to a Fraction 1/2 instead of Integer 1) and for 5 (lead to ZeroDivide).
The file is deleted when the exception is caught and 5 is returned.
Otherwise, an inspector is opened on the value, the display is refreshed, the process is paused during 1 second before evaluating next quine.
A process for closing opened inspectors after a longer pause is forked.
The source of quine is retrieved via the current context of execution (thisContext method getSource), written, then re-evaluated without the first line (the name of the method). So the second and successive evaluation do not evaluate #quine, but an anonymous (#Doit) method sharing exactly the same contents.
Based on same principles, this less funny example will print 00100 in Transcript then stop when evaluating 1 quine, but it avoids explicit 3 and 5 in source:
```
quine|v|v:=self highBit-self lowBit.Transcript show:(1bitAnd:v).(2bitAnd:v)=0or:[^FileDirectory default deleteFileNamed:'q'].(FileStream forceNewFileNamed:'q')nextPutAll:thisContext method getSource;close.^Compiler evaluate:((FileStream oldFileNamed:'q')contentsOfEntireFile allButFirst:5)for:self+1
```
] |
Subsets and Splits